Kling 2.6: Credit Pricing and API Code (2026)

Kling 2.6 is Kuaishou’s video generation model family, and the feature that separates it from the versions before it is native audio: a single request can return a clip with dialogue, sound effects and ambience already mixed into the file, instead of silent footage you have to score yourself. Kling AI is built and hosted by Kuaishou, a technology company based in Beijing, according to its Wikipedia entry, and the 2.6 generation shipped in three distinct shapes rather than one: text-to-video, image-to-video, and a separate motion control model that copies movement from a reference clip onto a character you supply.

This post covers what each of those three does, exactly what they cost in credits, the code to call them, how to write prompts that get the audio right, and the two pricing quirks that make people overspend without noticing.

What is Kling 2.6 and how is it different from 2.5?

A text-to-video model takes a natural language description and produces video that matches it, as the general category is defined. Most of them, including this family, are built on diffusion: the model starts from noise and denoises it step by step toward something that fits your prompt. The practical consequence is that you do not direct a render the way you direct a camera. You describe, you sample, and you iterate.

Three things are worth knowing about this generation specifically.

• Audio is generated with the picture, not after it. Speech, footsteps, room tone and music come out of the same pass, so lip movement and sound land together instead of needing manual sync.
• It ships as separate endpoints. Text-to-video, image-to-video and motion control are three different models with three different price tables. There is no single “Kling 2.6” endpoint that does everything.
• Resolution is not a dial on the generative modes. Text-to-video and image-to-video expose sound, duration, prompt and (for text) aspect ratio. Only the motion control model takes a resolution-style mode field. If you need a specific output size from the other two, you resize after the fact.

The three model pages are Kling 2.6 Text To Video and Kling 2.6 Image To Video, both released in December 2025, and Kling 2.6 Motion Control, which followed in January 2026. If you want a wider view of the family across generations, the Kling AI video generator overview walks through the older models too.

Kling 2.6 pricing in credits

Everything on Unicorn API is billed in credits. Monthly plans buy credits at $0.01 each (Starter $25, Creator $50, Studio $100, Pro $200), and top-up credits cost $0.015 each and never expire. Full plan details are on the pricing page. Here is the full Kling 2.6 price table.

Model	Configuration	Credits	At $0.01/credit
Text To Video	5s, no sound	55	$0.55
Text To Video	5s, with sound	110	$1.10
Text To Video	10s, no sound	110	$1.10
Text To Video	10s, with sound	220	$2.20
Image To Video	5s, no sound	110	$1.10
Image To Video	5s, with sound	110	$1.10
Image To Video	10s, no sound	110	$1.10
Image To Video	10s, with sound	220	$2.20
Motion Control	720p, per second	11	$0.11
Motion Control	1080p, per second	18	$0.18

Two things in that table deserve a second look.

Sound doubles the price, except where it does not. On text-to-video, turning sound on takes a 5-second clip from 55 to 110 credits and a 10-second clip from 110 to 220. On image-to-video, a 5-second clip costs 110 credits whether or not you ask for sound, so if you are generating image-to-video at 5 seconds you may as well take the audio you are already paying for.

Short image-to-video clips are the worst value in the family. A 5-second silent image-to-video render and a 10-second silent one both cost 110 credits. That is 22 credits per second at 5 seconds and 11 credits per second at 10. If you need a short silent shot from a still, render 10 seconds and trim it in post. Trimming is free, and frame rate and duration are the only things you are cutting.

Motion control is the one mode that bills by the second, multiplied by clip length and rounded up to whole credits, so an 8-second 720p render is 88 credits and the same clip at 1080p is 144. Because price depends on the exact combination of fields you send, call POST /v1/models/price with the same body you plan to submit and read the number back before you spend anything.

How to call Kling 2.6 text-to-video from the API

All media models follow the same two-step pattern: create a job, then poll it. Create an API key at /keys, export it, and the following curl call starts a 5-second clip with audio.

curl -s -X POST https://api.unicornapi.net/v1/jobs \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kling-2.6-text-to-video",
    "input": {
      "sound": true,
      "duration": "5",
      "aspect_ratio": "16:9",
      "prompt": "A night market stall in heavy rain. The vendor leans out and shouts \"two for one, last of the night\" in a hoarse voice. Rain hammers on the plastic awning, a scooter passes behind him. Handheld camera, slight push in."
    }
  }'

That returns a job object with an id and a status. Poll it until the status is succeeded:

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

When it finishes, the file lives at outputs[0].url. Download it rather than hotlinking it from your product, since generated output URLs are not a permanent CDN.

If you want to check the cost first, send the identical body to the pricing endpoint:

curl -s -X POST https://api.unicornapi.net/v1/models/price \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"kling-2.6-text-to-video","input":{"sound":true,"duration":"5","aspect_ratio":"16:9","prompt":"test"}}'

Image-to-video with polling, in Python

Image-to-video animates a still you provide. Pass a publicly reachable URL in image_urls, and remember the duration maths above: at 10 seconds you get twice the footage for the same 110 credits.

import os, time, requests

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

def render(model, payload, timeout=900):
    r = requests.post(f"{BASE}/v1/jobs", headers=HEADERS,
                      json={"model": model, "input": payload}, timeout=60)
    r.raise_for_status()
    job_id = r.json()["id"]

    deadline = time.time() + timeout
    while time.time() < deadline:
        time.sleep(5)
        job = requests.get(f"{BASE}/v1/jobs/{job_id}",
                           headers=HEADERS, timeout=30).json()
        status = job.get("status")
        if status == "succeeded":
            return job["outputs"][0]["url"]
        if status in ("failed", "canceled"):
            raise RuntimeError(f"{status}: {job.get('error')}")
    raise TimeoutError(job_id)

url = render("kling-2.6-image-to-video", {
    "sound": True,
    "duration": "10",
    "image_urls": ["https://example.com/stall-still.png"],
    "prompt": "The vendor turns toward camera and smiles. Rain continues on the awning, "
              "distant traffic hum. Camera holds still, shallow depth of field.",
})
print(url)

Poll every 5 seconds, not every 500 milliseconds. Video renders take tens of seconds to minutes depending on queue depth, and tight polling buys you nothing. The API docs cover webhooks if you would rather not hold a loop open, and if you want to see how a prompt behaves before you wire anything up, the video playground runs the same models in the browser.

Kling 2.6 Motion Control: inputs, price and limits

Motion control is the mode people search for most, and it is the least like the others. Instead of inventing movement from a description, it takes movement you already have and applies it to a character you supply. That makes it the tool for shots where the performance matters more than the invention: a specific gesture, a dance, a walk cycle, a head turn timed to dialogue.

It takes five fields:

• mode: "720p" or "1080p", which also sets your per-second rate.
• prompt: the scene description, same as the other modes.
• input_urls: the still image of the character you want on screen.
• video_urls: the reference clip whose motion gets copied.
• character_orientation: the minimal request uses "image"; check the model page for the current list of accepted values before you hardcode anything else.

curl -s -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 courier in a yellow rain jacket on a wet sidewalk at dusk, neon reflections",
      "input_urls": ["https://example.com/courier-reference.png"],
      "video_urls": ["https://example.com/walk-cycle.mp4"],
      "character_orientation": "image"
    }
  }'

On price: motion control is 11 credits per second at 720p and 18 at 1080p, multiplied by clip length and rounded up. That is the same 11 credits per second as text-to-video at its best rate, so it is not a premium feature in billing terms. Searches for “kling 2.6 motion control free” turn up promotional previews on various hosted front ends; those come and go and their terms change without notice, so treat them as a way to try the feature rather than a basis for a workflow. The API price is the stable number.

Two practical limits. First, your reference clip is doing the directing, so shoot or source it deliberately: a clean, well-lit, single-subject clip with the full body in frame retargets far better than a crowded one. Second, the model matches motion, not identity perfection. Faces drift across longer clips, which is why most people working seriously with it cut at 4 to 6 seconds per shot and stitch.

Writing a Kling 2.6 prompt that gets the audio right

Prompting for a model that generates sound is different from prompting an image model, because you are writing a shot list and an audio bed at once. The structure that works most reliably has four parts, in this order: subject and action, camera, audio, then style.

1. Subject and action. One subject, one clear action, present tense. “A chef lifts a pan and the contents flip” beats “a cooking scene”.
2. Camera. Name the move and the framing: “slow push in, medium shot”, “static wide”, “handheld, follows from behind”. Leaving camera unspecified is the single most common cause of a shot that wanders.
3. Audio. Say what you want to hear, in layers. Dialogue goes in quotation marks, then effects, then ambience: she says “we’re closing” flatly; pan sizzle; extractor fan hum. Quote marks are what separate lines you want spoken from narration about speaking.
4. Style. Lens, light, grade: “shot on 35mm, practical lighting, slight grain”.

Things that reliably go wrong when prompting this family:

• Multiple cuts in one prompt. Asking for “then the camera cuts to the street” at 5 seconds gives you a muddle. One prompt, one shot. Build sequences by generating shots separately and editing them together.
• Long dialogue in a short clip. A 5-second clip holds roughly one short line. Twenty words of script produces rushed, garbled speech.
• Negative instructions. “No music” tends to work less well than simply not mentioning music and describing the ambience you do want.
• Stacked adjectives. Six style words compete with each other. Three specific ones outperform them.

Because a render costs 55 credits at the cheap end, the sane iteration loop is to test prompt structure at 5 seconds without sound, lock the composition and camera, then re-run the winner with sound at the length you actually need. Many of the same habits carry over from still-image prompting, which the Nano Banana prompt guide covers in more depth.

End frames, ComfyUI and the features Kling 2.6 does not have

Two requests come up constantly, and both have honest answers rather than workarounds.

End frames

The Kling 2.6 endpoints accept a start image, prompt, duration and sound flag. There is no end frame field. If you need to pin both the first and last frame of a shot, which is how you make a clip loop or hand off cleanly to the next one, use a model that exposes it: Wan 3.0 takes end_image alongside image, and Wan 3.0 Video Prime takes first_frame_url and last_frame_url. Both go through the same POST /v1/jobs call, so switching is a change to the model id and the input keys, not a rewrite.

ComfyUI

Kling 2.6 is a hosted model, not a set of weights you can download, so it cannot run inside ComfyUI the way an open-weights checkpoint does. What works is treating it as a remote call inside your graph: a node capable of HTTP requests posts the job, polls GET /v1/jobs/{id} until the status is succeeded, and passes outputs[0].url downstream to your load-video node. The same logic applies to any node-based tool. If you drive your pipeline from an editor or coding agent instead, the MCP integration exposes the same models to Cursor and Claude Code.

Kling 2.6 vs cheaper video models

Kling 2.6 is mid-priced rather than cheap, and whether it is the right choice depends almost entirely on whether you need its audio and its motion fidelity. Here is how it compares against the other video models in the catalog, normalised to credits per second where possible.

Model	Cost (720p-class)	Audio	Max duration	Best for
Kling 2.6 Text To Video	11 credits/s silent, 22 with sound at 5s	Optional, native	10s	Dialogue shots from a prompt
Kling 2.6 Image To Video	11 credits/s at 10s	Optional, native	10s	Animating a locked composition
Kling 2.6 Motion Control	11 credits/s at 720p, 18 at 1080p	Not applicable	Clip length	Copying a specific performance
Grok Imagine Video 1.5	4 credits/s at 720p, 7 at 1080p	No	15s	High-volume silent b-roll from a still
Grok Imagine Video 1.0	4 credits/s at 720p, 7 at 1080p	No	30s	Long single takes on a budget
Wan 3.0	12 credits/s at 720p, 24 at 1080p	Included	30s	Long clips with audio and an end frame
Wan 3.0 Video Prime	25.2 credits/s at 720P, 50.4 at 1080P	Yes	Set by duration	Top-end quality with frame pinning

The decision is usually straightforward. If the shot has no sound and no performance requirement, Grok Imagine at 4 credits per second does the job for roughly a third of the price, and the comparison in the image-to-video walkthrough shows where its quality lands. If you need audio baked in and clips longer than 10 seconds, Wan 3.0 includes audio at 12 credits per second and goes to 30. Kling 2.6 earns its price on short dialogue shots and on motion control, where nothing else in the list does the same job.

A production checklist and the mistakes that cost money

If you are putting Kling 2.6 behind a product feature rather than generating clips by hand, these are the things that bite.

• Price every job before you submit it. POST /v1/models/price takes the same body as the job. Show the number to the user, or at least log it, so a duration change from 5 to 10 seconds with sound is never a surprise fourfold bill.
• Treat the sound flag as a per-shot decision. Defaulting it to true across a batch is the fastest way to double spend on clips nobody will listen to. Silent shots that get music in the edit should be generated silent.
• Never render 5-second silent image-to-video. It costs the same 110 credits as 10 seconds. Generate 10 and trim.
• Handle failures as a normal path. Prompts get rejected by content filters and jobs occasionally fail. Branch on failed and canceled explicitly and surface the error rather than letting a poll loop time out silently.
• Store the output immediately. Copy outputs[0].url to your own storage on success. Do not build a gallery that depends on generation URLs staying alive.
• Keep a cheaper model wired up. Because every model here is one model string in the same endpoint, falling back from Kling 2.6 to Grok Imagine when the queue is long or the budget is thin costs you a config line, not an integration.
• Cap duration in your own UI. The 10-second ceiling on the generative modes means product copy promising “a 30-second video” has to mean three stitched shots. Decide that before users do.

The short version: Kling 2.6 is the model to reach for when a shot needs synchronised sound or a specific performance, at 55 to 220 credits per clip depending on length and audio, and 11 to 18 credits per second for motion control. Everything else in the catalog is cheaper per second and worse at exactly those two things. One key from /keys covers all of them, so the real work is picking the right model per shot rather than committing to one.