WAN 3.0 is LIVE — 30s in one shot | Try in Video Generator →

kwaivgi/

Kling Elements creates custom AI elements from reference images for video generation. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing.

image-to-text
Input
Enable Safety Checker

Idle

kwaivgi/kling-elements preview unavailable

$0.01per run·~100 / $1

Next:

ExamplesView all

Related Models

README

Kling Elements

Kling Elements creates custom AI elements from reference images for video generation. Define reusable visual elements — characters, clothing, objects, or styles — that can be consistently applied across multiple Kling video generations.

Why Choose This?

  • Reusable AI elements Create custom elements once, use them across multiple video generations for consistent results.

  • Multi-reference support Upload multiple reference images to better capture the element's visual characteristics.

  • Character consistency Maintain the same character appearance, clothing, or style across different videos.

  • Simple workflow Define elements with a name, description, and reference images — ready to use in video generation.

  • Affordable pricing Just $0.01 per element creation.

Parameters

ParameterRequiredDescription
nameYesName for the element (e.g., "Work Suit", "Main Character")
descriptionYesDescription of the element's visual characteristics
imageYesPrimary reference image (URL or upload)
element_refer_listYesAdditional reference images (click "+ Add Item" to add)
tag_listNoTags for organizing and categorizing elements

How to Use

  1. Enter element name — give your element a clear, descriptive name.
  2. Write description — describe the element's visual characteristics in detail.
  3. Upload primary image — provide the main reference image.
  4. Add reference images — upload additional images showing the element from different angles or contexts.
  5. Add tags (optional) — categorize your element for easier management.
  6. Run — submit to create your custom AI element.
  7. Save the element_id — use this ID in Kling video generation to apply the element.

Pricing

OutputCost
Per element$0.01

Best Use Cases

  • Character Consistency — Create character elements for consistent appearance across video series.
  • Wardrobe Management — Define clothing elements for virtual try-on or fashion videos.
  • Brand Assets — Create reusable brand elements (logos, mascots, products) for marketing videos.
  • Style Templates — Define visual styles that can be applied consistently.
  • Product Visualization — Create product elements for e-commerce video content.

Pro Tips

  • Use multiple reference images showing the element from different angles for better recognition.
  • Write detailed descriptions including colors, textures, and distinctive features.
  • Keep element names clear and descriptive for easy identification later.
  • Use tags to organize elements by project, category, or use case.
  • Save the returned element_id — you'll need it to use the element in video generation.

Notes

  • All required fields (name, description, image, element_refer_list) must be provided.
  • The output includes an element_id that can be used in Kling video models.
  • Ensure uploaded image URLs are publicly accessible.
  • Multiple reference images improve element consistency.

Related Models

Note:This website uses AI models provided by third parties. Documentation prices are for reference and may be outdated. The Generate button shows an estimate; the final task charge prevails.

Kling Elements API — Quick start

Grab a WaveSpeedAI API key, then call POST https://api.wavespeed.ai/api/v3/kwaivgi/kling-elements with your input as JSON. The endpoint returns a prediction id. Start polling the result endpoint around every 2 seconds, increase the interval for long-running tasks, and stop on any terminal status. On completed, read output values from data.outputs. Examples for Kling Elements below.

HTTP example
set -euo pipefail

: "${WAVESPEED_API_KEY:?Set WAVESPEED_API_KEY}"

REQUEST_BODY=$(cat <<'JSON'
{
    "name": "example",
    "description": "example",
    "image": "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg",
    "element_refer_list": [
        "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg"
    ]
}
JSON
)

# 1. Submit the prediction.
SUBMIT_RESPONSE=$(curl --silent --show-error --fail-with-body \
  -X POST "https://api.wavespeed.ai/api/v3/kwaivgi/kling-elements" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $WAVESPEED_API_KEY" \
  -d "$REQUEST_BODY")

TASK=$(printf '%s' "$SUBMIT_RESPONSE" | jq 'if has("data") then .data else . end')
PREDICTION_ID=$(printf '%s' "$TASK" | jq -r '.id')
if [ -z "$PREDICTION_ID" ] || [ "$PREDICTION_ID" = "null" ]; then
  printf 'Submission response did not contain a prediction id
' >&2
  exit 1
fi
RESULT_URL="https://api.wavespeed.ai/api/v3/predictions/$PREDICTION_ID/result"

# 2. Poll until the prediction finishes.
while true; do
  RESPONSE=$(curl --silent --show-error --fail-with-body "$RESULT_URL" \
    -H "Authorization: Bearer $WAVESPEED_API_KEY")
  RESULT=$(printf '%s' "$RESPONSE" | jq 'if has("data") then .data else . end')
  STATUS=$(printf '%s' "$RESULT" | jq -r '.status')
  case "$STATUS" in
    completed) printf '%s\n' "$RESULT" | jq '.outputs'; break ;;
    failed|cancelled|timeout|deleted) printf '%s\n' "$RESULT" | jq . >&2; exit 1 ;;
    *) sleep 2 ;;
  esac
done
Node.js example
const submitUrl = "https://api.wavespeed.ai/api/v3/kwaivgi/kling-elements";
const apiKey = process.env.WAVESPEED_API_KEY;
if (!apiKey) throw new Error('Set WAVESPEED_API_KEY');

async function requestJson(url, options = {}) {
  const response = await fetch(url, options);
  if (!response.ok) throw new Error(await response.text());
  return response.json();
}

// 1. Submit the prediction.
const body = await requestJson(submitUrl, {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${apiKey}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
        "name": "example",
        "description": "example",
        "image": "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg",
        "element_refer_list": [
                "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg"
        ]
}),
});
const task = body.data ?? body;
if (!task.id) throw new Error("Submission response did not contain a prediction id");
const resultUrl = `https://api.wavespeed.ai/api/v3/predictions/${task.id}/result`;

// 2. Poll until the prediction finishes.
while (true) {
  const resultBody = await requestJson(resultUrl, {
    headers: { "Authorization": `Bearer ${apiKey}` },
  });
  const result = resultBody.data ?? resultBody;
  if (result.status === "completed") {
    console.log(result.outputs);
    break;
  }
  if (["failed", "cancelled", "timeout", "deleted"].includes(result.status)) throw new Error(JSON.stringify(result));
  await new Promise(resolve => setTimeout(resolve, 2000));
}
Python example
import json
import os
import time
from urllib.request import Request, urlopen

api_key = os.environ["WAVESPEED_API_KEY"]
headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
payload = {
    "name": "example",
    "description": "example",
    "image": "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg",
    "element_refer_list": [
        "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg"
    ]
}

def request_json(url, data=None):
    request = Request(url, data=data, headers=headers, method="POST" if data else "GET")
    with urlopen(request) as response:
        return json.load(response)

# 1. Submit the prediction.
body = request_json("https://api.wavespeed.ai/api/v3/kwaivgi/kling-elements", json.dumps(payload).encode())
task = body.get("data", body)
if not task.get("id"):
    raise RuntimeError("Submission response did not contain a prediction id")
result_url = f"https://api.wavespeed.ai/api/v3/predictions/{task['id']}/result"

# 2. Poll until the prediction finishes.
while True:
    result_body = request_json(result_url)
    result = result_body.get("data", result_body)
    status = result.get("status")
    if status == "completed":
        print(result.get("outputs", []))
        break
    if status in {"failed", "cancelled", "timeout", "deleted"}:
        raise RuntimeError(result)
    time.sleep(2)

Kling Elements API — Frequently asked questions

What is the Kling Elements API?

Kling Elements is a Kuaishou model for AI inference, exposed as a REST API on WaveSpeedAI. Kling Elements creates custom AI elements from reference images for video generation. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing. You can call it programmatically or try it from the playground above.

How do I call the Kling Elements API?

POST your input parameters to the model's REST endpoint (shown in the API tab of this playground) with your WaveSpeedAI API key in the Authorization header. Submission returns a prediction ID. Poll the result endpoint starting around every 2 seconds, increase the interval for long-running tasks, and stop on any terminal status. The playground generates production-oriented Python, JavaScript, and cURL examples with timeouts, transient-error handling, and safe GET retries. Full request/response shape is documented at https://wavespeed.ai/docs/docs-api/kwaivgi/kwaivgi-kling-elements.

How much does Kling Elements cost per run?

Kling Elements starts at $0.010 per run. That figure is the base price — the final charge scales with the parameters you set in the form (output size, length, count, references, or whatever knobs this model exposes), so a higher-quality or larger output costs more than a minimal one. The exact cost for your current input is shown live next to the Generate button before you submit, and the actual per-call charge is recorded on the prediction afterwards.

What inputs does Kling Elements accept?

Key inputs: `image`, `description`, `element_refer_list`, `name`, `tag_list`, `voice_id`. The full JSON schema (types, defaults, allowed values) is rendered above the Generate button and mirrored in the API reference at https://wavespeed.ai/docs/docs-api/kwaivgi/kwaivgi-kling-elements.

How long does Kling Elements take to generate?

Median end-to-end generation time on WaveSpeedAI is around 7 seconds per request, based on recent successful runs. Queue time varies with global demand; live status is visible in the prediction record.

Can I use Kling Elements outputs commercially?

Commercial usage rights depend on the model's license, set by its provider (Kuaishou). The license summary appears on the model card above; see WaveSpeedAI's Terms of Service for platform-level conditions.

Kling Elements | Fast Image-to-Video API on WaveSpeedAI