Using Kling 2.6 Motion Control: Pricing and API Code (2026)

Kling 2.6 Motion Control takes two files, a still image of a character and a short video of someone moving, and produces a new clip where your character performs exactly that motion. It works for dance moves, hand gestures, a walk across a room or a presenter’s delivery: if you can film the movement, you can transfer it. This guide explains how the model reads its inputs and what each second costs. It also includes working API code and the mistakes that most often waste credits.

What is Kling 2.6 Motion Control?

Kling 2.6 Motion Control is a video model from Kling, released on January 4, 2026, in the same 2.6 family as Kling 2.6 Text To Video and Kling 2.6 Image To Video. It does motion transfer: it takes the body movement from one video and applies it to a different character supplied as an image.

This matters because of how most AI video works. A standard image-to-video model reads your prompt (“she spins and waves”) and makes up the movement. The result might be good, but you can’t control the timing, the exact pose at second three, or how a hand moves. With Kling 2.6 Motion Control the motion isn’t made up. It comes from real footage you supply, so the choreography is fixed and the model’s job is to render your character doing it convincingly.

Typical uses:

• Character animation without rigging. Film yourself acting a scene and give the performance to an illustrated or 3D-styled character.
• Dance and trend content. Apply one recorded routine to several different characters or mascots.
• Consistent brand presenters. Record a real person’s gestures once and render them onto a designed spokesperson.
• Previsualization. Block out a shot with a phone recording and see it rendered in the target look before a real shoot.

The model doesn’t edit your reference video. It generates new frames of the character in your image, guided by the movement it finds in the video.

How motion transfer works: the inputs

A Kling 2.6 Motion Control job has five input fields. Knowing what each one controls is most of the skill.

• input_urls: the character image. This decides who appears in the clip: face, outfit, body shape and art style. Use a public URL to a clear still.
• video_urls: the reference video. This decides how the character moves. The model follows the body movement in this clip.
• prompt: the text description. This fills in what the two files don’t cover, such as environment, lighting, camera feel and small details.
• mode: output resolution. Either "720p" or "1080p". This choice also sets the price.
• character_orientation: which input sets the character’s orientation. The minimal request uses "image", which takes the orientation from your still. The API documentation lists the accepted values.

Conceptually, the model does something similar to pose estimation (finding the positions of head, shoulders, elbows, hips, knees and so on in each frame). It then re-renders your character’s appearance in those positions frame by frame, keeping the identity from the image stable while the body moves. That’s why clean, readable movement in the reference video matters more than anything else: if the model can’t see a limb, it has to guess.

There’s no duration field. The clip length follows the motion you supply, so the easiest way to control both length and cost is to trim the reference video before uploading it.

Kling 2.6 Motion Control pricing

On Unicorn API, Kling 2.6 Motion Control is billed per second of output:

• 720p: 11 credits per second
• 1080p: 18 credits per second

The total is the per-second rate multiplied by the clip length, rounded up to whole credits. Credits from a monthly plan cost $0.01 each (Starter $25, Creator $50, Studio $100, Pro $200 per month). Top-up credits cost $0.015 each and never expire. Here’s what typical clip lengths cost:

Clip	Credits	Cost on a plan ($0.01/credit)	Cost on top-up ($0.015/credit)
5 s at 720p	55	$0.55	$0.825
10 s at 720p	110	$1.10	$1.65
5 s at 1080p	90	$0.90	$1.35
10 s at 1080p	180	$1.80	$2.70

The rounding only matters for odd lengths. A clip of 7.4 seconds at 720p works out to 81.4 credits and is billed as 82.

For budgeting, the Starter plan’s 2,500 credits cover about 227 seconds of 720p output, or about 138 seconds at 1080p. The Studio plan’s 10,000 credits cover about 909 seconds at 720p, roughly 15 minutes. Iteration usually takes more renders than you expect, so plan for several test passes per final clip.

You don’t have to estimate. Call POST /v1/models/price with the same model and inputs and it returns the exact credit cost before anything runs. Full plan details are on the pricing page.

People often search for a free way to use Kling 2.6 Motion Control. Every render uses real GPU time, so each run on Unicorn API costs credits at the rates above. The practical way to keep costs down is to test at 720p with short, trimmed clips, then render at 1080p only once the motion looks right.

How to call the Kling 2.6 Motion Control API

Like every media model on Unicorn API, Kling 2.6 Motion Control runs as an asynchronous job: you create the job, it runs in the background, and you poll until it finishes. There are four steps:

1. Create an API key on the keys page and export it as UNICORN_API_KEY.
2. Host your character image and reference video at publicly reachable URLs, for example in a storage bucket with public read access or behind a signed URL.
3. Send POST /v1/jobs with the model id and inputs.
4. Poll GET /v1/jobs/{id} until status is "succeeded", then download outputs[0].url.

Create the job with curl

curl -X POST https://api.unicornapi.net/v1/jobs \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kling-2.6-motion-control",
    "input": {
      "mode": "720p",
      "prompt": "A cartoon fox in a red hoodie dancing on a neon-lit rooftop at night, city skyline behind, soft rim lighting",
      "input_urls": ["https://your-bucket.example.com/fox-character.png"],
      "video_urls": ["https://your-bucket.example.com/dance-reference.mp4"],
      "character_orientation": "image"
    }
  }'

The response includes the job’s id. Check on it with:

curl https://api.unicornapi.net/v1/jobs/JOB_ID \
  -H "Authorization: Bearer $UNICORN_API_KEY"

A complete Python script

This script creates the job, polls every five seconds and saves the finished video to disk.

import os
import time
import requests

API = "https://api.unicornapi.net"
HEADERS = {
    "Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}",
    "Content-Type": "application/json",
}

payload = {
    "model": "kling-2.6-motion-control",
    "input": {
        "mode": "720p",
        "prompt": (
            "A cartoon fox in a red hoodie dancing on a neon-lit rooftop at night, "
            "city skyline behind, soft rim lighting"
        ),
        "input_urls": ["https://your-bucket.example.com/fox-character.png"],
        "video_urls": ["https://your-bucket.example.com/dance-reference.mp4"],
        "character_orientation": "image",
    },
}

resp = requests.post(f"{API}/v1/jobs", json=payload, headers=HEADERS)
resp.raise_for_status()
job = resp.json()
job_id = job["id"]
print("Created job", job_id)

while True:
    job = requests.get(f"{API}/v1/jobs/{job_id}", headers=HEADERS).json()
    status = job["status"]
    print("Status:", status)
    if status == "succeeded":
        break
    if status == "failed":
        raise RuntimeError(f"Job failed: {job}")
    time.sleep(5)

video_url = job["outputs"][0]["url"]
video = requests.get(video_url)
with open("motion-control.mp4", "wb") as f:
    f.write(video.content)
print("Saved motion-control.mp4 from", video_url)

The minimal example in the docs uses placeholder file names. In real requests, video_urls should point to an actual video file and input_urls to an image. If you’d rather test inputs before writing code, the video playground runs the same models in the browser. If you work in Cursor or Claude Code, the MCP setup lets your agent start jobs directly.

Preparing reference videos and character images

Most poor results come from the input files, not the prompt. Spend your effort here first.

The reference video

• One person, fully visible. Two people in frame make the model guess whose motion to follow. Keep hands and feet inside the frame for the whole clip.
• Steady camera. A tripod or a phone propped against something is better than handheld. Camera shake can be read as body movement.
• Even light and a plain background. High contrast between the person and the background makes the pose easier to read.
• Clothing that shows the body’s shape. Very loose coats or long skirts hide knees and elbows, so the model has to guess where they are.
• Trimmed to the motion. Cut the walk-in, the pause and the walk-out. You pay for every second of output.

The character image

• Match the framing. A full-body reference video needs a full-body character image. A waist-up video needs a waist-up image. Mismatches are the single most common cause of warped limbs.
• Neutral, open pose. Arms slightly away from the body and legs visible give the model a clean starting map of the character.
• Clear detail. A sharp face and well-lit outfit help identity stay stable through fast movement.
• Uncluttered background. Describe the scene in the prompt rather than relying on a busy backdrop in the still.

If you don’t have a character image yet, an image model can design one. The guide on how to use Nano Banana covers creating consistent character stills you can then animate.

Writing prompts for Kling 2.6 Motion Control

Kling 2.6 prompts for motion control work differently from text-to-video prompts. The movement already comes from your footage, so you don’t need to describe it. Use the prompt for everything else:

• Setting: where the character is (“on a neon-lit rooftop”, “in a sunlit kitchen”).
• Lighting and mood: “soft morning light”, “hard stage spotlight”, “overcast and cool”.
• Style: “cel-shaded animation”, “photoreal”, “claymation texture”, usually matching the style of your character image.
• Secondary details: hair and fabric movement, props, background activity.

Three examples that follow this pattern:

1. “A knight in silver armor on a misty castle courtyard at dawn, cinematic lighting, cape moving with each step.”
2. “A 3D-animated robot mascot on a clean white studio set, soft shadows, glossy plastic surfaces.”
3. “An illustrated girl with a yellow raincoat on a rainy city street at night, reflections on wet pavement, warm shop lights.”

Avoid describing motion that contradicts the footage. If your reference shows someone waving with their right hand and the prompt says “jumps in the air”, the model receives conflicting instructions, and you’ll usually see jitter or mangled limbs. Keep motion words consistent with the video or leave them out.

Kling 2.6 Motion Control vs other video models

Motion transfer is the right tool when exact movement matters. When it doesn’t, a cheaper or simpler model may serve you better. Here’s how the options in the model catalog compare:

Model	Inputs	What drives the motion	Price on Unicorn API
Kling 2.6 Motion Control	Character image + reference video + prompt	Your footage	11 credits/s at 720p, 18 at 1080p
Kling 2.6 Image To Video	Image + prompt	The prompt	110 credits for 5 s or 10 s without sound, 220 for 10 s with sound
Kling 2.6 Text To Video	Prompt only	The prompt	55 credits for 5 s without sound, up to 220 for 10 s with sound
Grok Imagine Video 1.5	Start frame + prompt	The prompt	3 credits/s at 480p, 4 at 720p, 7 at 1080p (1-15 s)
Vidu Q4 Reference To Video	Reference images (and optional audio) + prompt	The prompt	15.2 credits/s at 720p, 19.2 at 1080p, up to 62.4 at 4K

Some practical guidance:

• Choose Kling 2.6 Motion Control when the choreography, gesture timing or performance has to match something specific. No prompt will reliably reproduce a particular dance routine, but a reference clip will.
• Choose Kling 2.6 Image To Video when you have a still and want natural movement without filming anything. It can also add sound, which the motion control request doesn’t offer as a field. The Kling 2.6 pricing and code guide covers the whole family.
• Choose Grok Imagine Video 1.5 for high-volume, low-cost animation from a start frame. A 5-second clip at 720p costs 20 credits. It can be busy at peak times. More detail is in the Grok Imagine guide.
• Choose Vidu Q4 Reference To Video when you want a character kept consistent from several reference images, and the movement doesn’t need to match footage.

Per second, Kling 2.6 Motion Control at 720p sits between the budget options and the premium ones. A 5-second clip costs 55 credits, compared with 110 for Kling 2.6 image-to-video at the same length.

Common mistakes and how to avoid them

1. Mismatched framing. Pairing a headshot with a full-body dance video forces the model to invent a body. Match the crop of the image to the crop of the video.
2. Untrimmed reference clips. Leaving five seconds of standing still at each end can nearly double the bill for the same usable motion. Trim first.
3. Rendering 1080p too early. At 18 credits per second compared with 11, test passes at 1080p cost about 1.6x as much. Validate at 720p, then do the final render at 1080p.
4. Fast motion with blur. Quick spins filmed in low light produce blurred frames where limbs disappear. Film in good light and, if your camera allows, at a higher shutter speed.
5. Multiple people or reflections. Mirrors, crowds or a second person walking past can pull the motion off course. Film against a plain wall.
6. Prompts that fight the footage. Describe the scene, not a different action.
7. Private or wrong file URLs. The API must be able to fetch both files. A link that needs a login, or an image URL placed in video_urls, will fail or give useless output.
8. Skipping the price check. When you batch many clips of different lengths, call POST /v1/models/price first so the total doesn’t surprise you.

Kling 2.6 Motion Control rewards preparation: a clean reference clip, a matching character still and a prompt that only describes the scene will get you most of the way on the first try. Start with a short 720p test in the playground or with the Python script above. Once the motion looks right, scale up to 1080p and batch renders through the API.