Kling 4.0 API

Every call goes to https://kling4.video/v1 with your key in the Authorization header as a Bearer token. Bodies are JSON, and the create call refuses any other Content-Type. Rendering is asynchronous: you never wait on the create call for the video.

1. Get an API key

Sign in, open Settings → API keys and create a key with a name of up to 32 characters. The secret starts with sk_sd_ and is displayed once, so store it straight away in your server environment (the examples read KLING4_API_KEY). Keys have no expiry date and stop working only when you revoke them on that page. Call the API from a backend, never from a browser or app bundle.

2. Create a task and poll it

This asks for 8 seconds of vertical 720p video. A 200 response only means the task was accepted and its credits are on hold; the status reads pending while it waits, processing while it renders, then completed or failed. Checking every 5 to 10 seconds is enough.

# Create a Kling 4.0 task
curl https://kling4.video/v1/videos/generations \
  -H "Authorization: Bearer $KLING4_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kling_v4",
    "prompt": "A street cellist plays under a railway bridge at dawn, pigeons lift off as a train rumbles overhead, slow push-in",
    "duration": 8,
    "quality": "720p",
    "aspect_ratio": "9:16"
  }'
# Response: {"task_id": "...", "status": "pending", "created_at": "..."}

# Poll it until status is "completed" or "failed"
curl https://kling4.video/v1/tasks/$TASK_ID \
  -H "Authorization: Bearer $KLING4_API_KEY"

Python

With requests, polling every 8 seconds:

import os
import time

import requests

BASE = "https://kling4.video/v1"
AUTH = {"Authorization": f"Bearer {os.environ['KLING4_API_KEY']}"}

job = requests.post(
    f"{BASE}/videos/generations",
    headers=AUTH,
    json={
        "model": "kling_v4",
        "prompt": "A street cellist plays under a railway bridge at dawn, pigeons lift off as a train rumbles overhead, slow push-in",
        "duration": 8,
        "quality": "720p",
        "aspect_ratio": "9:16",
    },
    timeout=30,
)
job.raise_for_status()
task_id = job.json()["task_id"]

while True:
    time.sleep(8)
    res = requests.get(f"{BASE}/tasks/{task_id}", headers=AUTH, timeout=30)
    if res.status_code == 429:
        continue
    res.raise_for_status()
    task = res.json()
    if task["status"] == "completed":
        print(task["output"]["video_url"], task["credits_used"])
        break
    if task["status"] == "failed":
        raise RuntimeError(task["error"])

Node.js

The same flow with fetch:

// Node 18+ (built-in fetch), saved as an ES module (.mjs)
const BASE = 'https://kling4.video/v1';
const auth = { Authorization: `Bearer ${process.env.KLING4_API_KEY}` };
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const created = await fetch(`${BASE}/videos/generations`, {
  method: 'POST',
  headers: { ...auth, 'Content-Type': 'application/json' },
  body: JSON.stringify({
    model: 'kling_v4',
    prompt: 'A street cellist plays under a railway bridge at dawn, pigeons lift off as a train rumbles overhead, slow push-in',
    duration: 8,
    quality: '720p',
    aspect_ratio: '9:16',
  }),
});
if (!created.ok) throw new Error(`${created.status} ${await created.text()}`);
const { task_id } = await created.json();

while (true) {
  await sleep(8000);
  const res = await fetch(`${BASE}/tasks/${task_id}`, { headers: auth });
  if (res.status === 429) continue;
  if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
  const task = await res.json();
  if (task.status === 'completed') {
    console.log(task.output.video_url, task.credits_used);
    break;
  }
  if (task.status === 'failed') throw new Error(task.error);
}

A completed task carries output.video_url, a link to the MP4 that Kling4 stores, plus output.duration, output.quality and credits_used. A failed one has output set to null and a readable reason in error.

The create call takes these fields and nothing else; an unknown field is rejected with 422 and its name in param.

Only these Kling model IDs are accepted by the API:

Four limits apply, and each one answers HTTP 429:

• Per key: 120 requests in each 60-second window, across all three endpoints. A window opens with the first request and closes 60 seconds later, however steady the traffic, so a script polling every 8 seconds never reaches the cap. Past it, calls get rate_limit_exceeded with a Retry-After header counting the seconds left in the window.
• Per IP address, before the key is checked: create calls at least 1 s apart and no more than 20 a minute; reads of one task URL or of /v1/credits at least 0.1 s apart and no more than 180 a minute. These replies carry a Retry-After header and a shorter body, {"error": "too_many_requests", "message": "..."}, without a request ID.
• Per account, videos rendering at the same time: 1 on Free, Lite or packs only, 4 on Pro and 8 on Premium. Videos started in the web app count. One more create returns concurrent_generation_limit_reached.
• The per-key count is shared by every server. The IP limits are counted on each server instance, so treat them as a ceiling to stay under, not a quota to plan around.

Honor Retry-After when it is sent, otherwise back off with some jitter. Poll each task every 5 to 10 seconds, stop as soon as it finishes, and let long batch jobs wait out Retry-After instead of failing on it.

The API documentation has every field, response and error code in detail; it is written for developers and kept out of search. To test a prompt before wiring it into code, try Kling 4.0 in the browser, where one 5-second clip needs no account.