guides

Kling 4.0 Flash API Guide: Parameters, Pricing and Code

Poyo.ai Team
13 min read
Share:

Key takeaways

  • Kling 4.0 Flash is the fast, lower-cost tier of Kling 4.0. It makes 3–20-second clips at 720p from text, a starting image or references, and it edits existing videos.
  • One model ID covers every mode. Send "model": "kling-4.0-flash" to POST /api/generate/submit. The media you include selects text-to-video, image-to-video, reference-to-video or editing.
  • It costs $0.094 per output second on PoYo (18.8 credits) for text, image and image-reference jobs, so a 5-second clip is $0.47 and a 10-second clip is $0.94. When video is an input, the rate is $0.063 per billed second.
  • Pay as you go with one key. PoYo bills Flash from pay-as-you-go credits with no subscription, and the same key and request format run Kling 4.0, Gemini Omni and Veo.
  • Results are asynchronous. Save the task_id, then poll GET /api/generate/status/{task_id} or set a callback_url.
  • Switching to Kling 4.0 is a one-word change. Both models share the same request fields; Kling 4.0 adds 1080p, 30-second clips, end frames and multi-shot prompts.

Kling 4.0 Flash at a glance

Kling 4.0 Flash on PoYo
DeveloperKuaishou (Kling AI)
API model IDkling-4.0-flash
Model page/models/kling-4-0-flash
ModesText-to-video, image-to-video (one starting frame), reference-to-video, video editing
Clip length3–20 seconds, whole seconds; default 5
Resolution720p (8-bit SDR, per Kling)
Aspect ratios16:9 (default), 9:16, 1:1, 21:9, auto
ReferencesUp to 10 images, 5 videos and 7 subjects, 15 items in total
Input video budgetAll source, reference and subject videos together up to 20 seconds
Prompt lengthUp to 26,000 characters
Price$0.094/s · $0.063 per billed second with video input

What is Kling 4.0 Flash?

Kling 4.0 Flash is the speed-focused member of Kuaishou's Kling 4.0 video family. Kling's own guide describes it as built for frequent creation, combining "fast generation with excellent value", and lists 3–20-second clips at 720p with text-to-video, image-to-video and Omni Reference. The full Kling 4.0 model goes up to 30 seconds and 1080p on PoYo and adds start-and-end frames and multi-shot prompts.

"Kling 4 Flash" and "Kling 4.0 Flash" are the same model. On PoYo, the page slug is kling-4-0-flash and the API model ID is kling-4.0-flash, with a dot.

Use Flash where volume and turnaround matter more than maximum resolution: social clips, hook and format tests, product loops, previs and draft rounds before a final render.

A 720p Kling 4.0 Flash clip: two martial artists spar in a sunlit wooden dojo. Example from the PoYo model page.

One model ID, four modes

PoYo picks the mode from the fields inside input:

ModeSendNotes
Text-to-videopromptChoose aspect_ratio
Image-to-videoimage_urls with exactly one imageprompt is optional; the starting image sets the framing
Reference-to-videoreference_image_urls, reference_video_urls and/or kling_elementsAn optional starting frame in image_urls counts toward the 10-image limit
Video editingvideo_url + promptAdd reference images, up to 4 reference videos and subjects; framing follows the source video

The priority is fixed: video_url selects editing, any reference field selects reference-to-video, image_urls alone selects image-to-video, and a prompt alone selects text-to-video.

Request parameters

model and callback_url sit at the top level; every other field goes inside input.

FieldTypeValues and limitsDefault
modelstringkling-4.0-flashRequired
callback_urlstringPublic URL that receives a POST when the task finishes or fails—
promptstring1–26,000 characters; required for text, reference and editing; optional for image-to-video—
durationinteger3–205; in editing, the source length
resolutionstring720p720p
aspect_ratiostringauto, 16:9, 9:16, 1:1, 21:9 (text and reference modes)16:9
image_urlsarrayExactly one starting image—
reference_image_urlsarrayUp to 10 images—
reference_video_urlsarrayUp to 5 videos (4 when editing), each 3–20 seconds—
kling_elementsarrayUp to 7 subjects; each has either element_input_urls (2–4 images, frontal view first) or element_input_video_urls (exactly one 3–8-second video); up to 3 video subjects—
video_urlstringSource video for editing, 3–20 seconds—

Shared limits to validate before you submit:

  • 15 items in total: starting frame + reference images + reference videos + subjects.
  • 20 seconds of input video in total: source video + reference videos + video subjects.
  • Tags follow array order: @Image1, @Video1, @Element1. When editing, the source video is @Video1 and reference videos start at @Video2.
  • Upload formats in the Playground: MP4 or MOV, up to 200 MB per video. Media URLs must be public HTTP or HTTPS links.

Submit your first request

Create an API key in the PoYo dashboard and keep it on your server. Then submit a five-second text-to-video task:

curl https://api.poyo.ai/api/generate/submit \
  -H "Authorization: Bearer $POYO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kling-4.0-flash",
    "input": {
      "prompt": "A ceramic mug of coffee steams on a wooden windowsill as rain streaks the glass. Slow push-in, soft morning light, clean frame free of text and logos.",
      "duration": 5,
      "aspect_ratio": "16:9"
    }
  }'

A successful submission returns code: 200 and a task in data:

{
  "code": 200,
  "data": {
    "task_id": "YOUR_TASK_ID",
    "status": "not_started",
    "created_time": "2026-11-14T10:30:00"
  }
}

Validation errors can also come back with HTTP 200 and code: 400, so check the code field as well as the HTTP status. 402 means the account needs more credits.

More request examples

Image-to-video from one starting frame

{
  "model": "kling-4.0-flash",
  "input": {
    "image_urls": ["https://example.com/red-panda.png"],
    "prompt": "The red panda shakes the snow off its fur, then turns toward the camera. Slow push-in, shallow depth of field.",
    "duration": 5
  }
}

Image-to-video result: a red panda on a snowy bamboo branch shakes off the snow and turns toward the camera. 5 seconds, 94 credits. Example from the PoYo model page.

Reference-to-video with a subject

The subject below uses a front view and a side view. The prompt refers to it as @Element1 and to the location image as @Image1:

{
  "model": "kling-4.0-flash",
  "input": {
    "prompt": "@Element1 walks along the cliff-top path toward the lighthouse in @Image1 at golden hour. The camera tracks beside him as he stops and looks up at the lamp. Keep his face and yellow raincoat consistent with @Element1.",
    "reference_image_urls": ["https://example.com/lighthouse.png"],
    "kling_elements": [
      {
        "element_input_urls": [
          "https://example.com/keeper-front.png",
          "https://example.com/keeper-side.png"
        ]
      }
    ],
    "duration": 8,
    "aspect_ratio": "9:16"
  }
}

Reference-to-video result: a lighthouse keeper in a yellow raincoat and red beanie walks the cliff path toward the lighthouse at golden hour, built from a location image and a two-view subject. 8 seconds, 9:16, 150.4 credits. Example from the PoYo model page.

Edit an existing clip

The output keeps the source length by default:

{
  "model": "kling-4.0-flash",
  "input": {
    "video_url": "https://example.com/winter-clip.mp4",
    "reference_image_urls": ["https://example.com/spring-bamboo.png"],
    "prompt": "Edit @Video1 and change the season from winter to spring, using @Image1 as the environment reference. Keep the animal, its movements, timing and camera motion exactly as in @Video1."
  }
}

Editing result: the snowy red panda clip from above, changed to spring with green bamboo and cherry blossoms while the panda's movement and camera motion stay the same. 151.2 credits. Example from the PoYo model page.

Poll the task status

Check a task at any time with its ID:

curl https://api.poyo.ai/api/generate/status/YOUR_TASK_ID \
  -H "Authorization: Bearer $POYO_API_KEY"

The status moves from not_started to running, then to finished or failed. A finished task lists the video in data.files, with file_url and file_type: "video". A failed task has an error_message.

A bounded Python loop for your backend:

import os
import time
import requests

API = "https://api.poyo.ai"
HEADERS = {"Authorization": "Bearer " + os.environ["POYO_API_KEY"]}

def data_or_raise(resp):
    resp.raise_for_status()
    body = resp.json()
    if body.get("code") not in (0, 200):
        raise RuntimeError(body.get("message") or body)
    return body["data"]

task = data_or_raise(requests.post(f"{API}/api/generate/submit", headers=HEADERS, json={
    "model": "kling-4.0-flash",
    "input": {
        "prompt": "A paper lantern drifts up over a night market. Slow tilt up, warm light, glowing stalls below.",
        "duration": 5,
        "aspect_ratio": "9:16",
    },
}, timeout=60))
task_id = task["task_id"]
print("task:", task_id)

deadline = time.monotonic() + 20 * 60
while time.monotonic() < deadline:
    status = data_or_raise(requests.get(f"{API}/api/generate/status/{task_id}", headers=HEADERS, timeout=60))
    if status["status"] == "finished":
        print([f["file_url"] for f in status.get("files", []) if f.get("file_type") == "video"])
        break
    if status["status"] == "failed":
        raise RuntimeError(status.get("error_message") or "generation failed")
    time.sleep(10)
else:
    print("Still running; check this task_id again later:", task_id)

If the loop times out, query the same task_id again later; each new submission is a separate, billed clip. For production pipelines, a top-level callback_url replaces polling with a webhook.

Kling 4.0 Flash cost per clip

PoYo bills Flash by the second on pay-as-you-go credits ($1 = 200 credits). For text, image and image-reference jobs, you pay for the output duration at one flat rate, with reference images and image subjects included.

Output lengthCreditsUSD
3 s56.4$0.282
5 s94$0.47
8 s150.4$0.752
10 s188$0.94
15 s282$1.41
20 s376$1.88

For comparison, the same 5-second clip on Kling 4.0 at 720p costs $0.7125, so Flash is about 34% cheaper.

With video input

When a request includes a source video, reference videos or video subjects, the rate is 12.6 credits ($0.063) per billed second, where:

billed seconds = output duration + max(total input video duration rounded up, output duration)

JobBilled secondsCreditsUSD
5-s clip guided by one 4-s reference video5 + max(4, 5) = 10126$0.63
10-s clip guided by 12 s of reference video10 + max(12, 10) = 22277.2$1.386
Edit an 8-s clip, keep its length8 + max(8, 8) = 16201.6$1.008
Edit a 15-s clip with one 5-s reference video15 + max(20, 15) = 35441$2.205

Fractional input lengths round up. The spring edit on the model page used a source of just over 5 seconds, which counted as 6: 6 + 6 = 12 billed seconds, or 151.2 credits. For budgeting across the whole Kling 4.0 family, see our Kling 4.0 API pricing guide.

Prompt tips for Kling 4.0 Flash

  1. One continuous action per clip. Short clips are most stable when the prompt follows one subject through one beat: "turns, pauses, looks up". Save multi-beat stories for 10–20-second clips, written as establish, act, resolve.
  2. Name the camera move. Push-in, orbit, tracking shot, tilt up. Put it in its own sentence so it stands out from the visual details.
  3. Describe light and texture. Time of day, light direction and materials such as wet glass, brushed metal or fur give a 720p clip a clear, consistent look.
  4. Tag every input. Refer to media as @Image1, @Video1 and @Element1 in array order, and say what each one controls: identity, location, motion or style.
  5. Build subjects carefully. Put the frontal view first, add 1–3 extra angles, and keep backgrounds plain. For a video subject, use one clear 3–8-second clip.
  6. Start edits with "Edit @Video1". Then state the change and list what must stay the same: identity, movement, timing and camera path.
  7. Ask for clean frames. Add "clean frame, free of text and logos" when you plan to add captions or branding later.
  8. Match length to the idea. A 5-second clip fits one gesture or reveal. Save 15–20 seconds for actions that need the room, since cost scales with every second.

Directed camera work in Kling 4.0 Flash: the camera circles a race car drifting through smoke under neon lights, then holds on its front. Example from the PoYo model page.

For more prompt patterns that work across the family, see the Kling 4.0 prompt guide and the Omni Reference guide.

Kling 4.0 Flash vs Kling 4.0 in brief

Kling 4.0 FlashKling 4.0
Model IDkling-4.0-flashkling-4.0
Resolution720p720p, 1080p
Clip length3–20 s3–30 s
FramesOne starting frameStarting and ending frames
Multi-shot promptsOne prompt per clipmulti_prompt with per-shot durations
Editing referencesImages, up to 4 reference videos and subjectsImages and image subjects
720p price, text and image jobs$0.094/s$0.1425/s

Draft on Flash and move the chosen direction to Kling 4.0 when the final cut needs 1080p, an end frame or more than 20 seconds. For the full comparison, read Kling 4.0 vs Flash. To see how Flash compares with Google's fast video models, read Gemini Omni 1.2 Flash vs Kling 4.0 Flash vs Veo 3.1.

FAQ

What is the Kling 4.0 Flash model ID?

kling-4.0-flash. The page slug kling-4-0-flash is used in the URL. Send "model": "kling-4.0-flash" in the request body.

How much does Kling 4.0 Flash cost?

On PoYo, 18.8 credits ($0.094) per output second for text, image and image-reference jobs: $0.47 for 5 seconds, $0.94 for 10 seconds and $1.88 for 20 seconds. When video is an input, it is 12.6 credits ($0.063) per billed second.

Is Kling 4 Flash free?

Kling 4.0 Flash runs on pay-as-you-go credits on PoYo, with no subscription. Each run is billed from your credit balance, and the Playground shows the credit estimate before you generate, so you can check the cost of a prompt, reference set or edit first.

How long can Kling 4.0 Flash videos be?

3 to 20 seconds per generation, in whole seconds. The default is 5 seconds, and edits keep the source length unless you set duration.

When should I move from Flash to Kling 4.0?

Flash is built for 720p clips from a prompt, a starting frame or references. For 1080p, an ending frame, multi_prompt or clips up to 30 seconds, use Kling 4.0 with the same request fields.

Is Kling 4.0 Flash faster than Kling 4.0?

Kling describes Flash as its faster tier, built for frequent creation and quick iteration. Generation time depends on clip length and current load, so time a few of your own prompts.

Can I use the same key for other video models?

Yes. The PoYo key that runs Kling 4.0 Flash also runs Kling 4.0, Gemini Omni 1.2 Flash, Veo 3.1 and other models, through the same submit and status endpoints and one credit balance.

Can I get a webhook when the video is ready?

Yes. Add a top-level callback_url, and PoYo sends a POST to it when the task finishes or fails. You can still query the status endpoint with the same task_id at any time.

Share: