Kling 3.0 API: access, pricing and code

Summary

There is a Kling API, and Runway Dev gives you the official Kling 3.0 API from Kling in three tiers: Kling 3.0 Pro, Kling 3.0 Standard and Kling 3.0 4K. Kling 3.0 is Kling’s video model for multi-shot clips with native audio, made from a prompt or from a first and last frame. Pro renders at 1080p and Standard at 720p for less, while the 4K tier renders the largest size. This page covers access, pricing, inputs and code, and how your coding agent can build the integration for you.

What is Kling 3.0?

Kling 3.0 is Kling’s video generation model for multi-shot clips with sound. It turns a text prompt, or a first frame with an optional last frame, into a clip of 3 to 15 seconds, with dialogue, sound effects and ambient sound generated in the same pass. One request can hold up to 6 shots, each with its own prompt and length, and the model keeps the scene consistent across the cuts.

Shot 1: Locked-off wide shot of a campfire on an empty pebble beach at dusk, a ring of stones around it, the calm sea and a purple sky behind, small flames and a thin column of smoke. Audio: soft waves on the pebbles and the low crackle of the fire.

Shot 2: Locked-off close shot of the same campfire in its ring of stones, the same sea behind: a burning log collapses into the embers and a burst of sparks rises into the dusk. Audio: a sharp pop and crackle as the log falls, then the soft waves again.

Reference images and video editing are on Kling O3, a separate model, and Kling 2.5 Turbo Pro is an earlier one.

What is the difference between Kling 3.0 Standard, Pro and 4K?

Kling 3.0 Standard, Kling 3.0 Pro and Kling 3.0 4K take the same endpoints, fields and durations, and differ in output size and price. The tier sets the resolution: Standard renders at 720p, Pro at 1080p and 4K at the largest size, each in landscape, portrait or square. Standard and Pro cost less without audio, while 4K costs the same with or without it.

The same prompt, sent to each tier:

Locked-off wide shot of a curved stone viaduct crossing a green valley on a clear morning: a dark green steam locomotive with no markings pulls three red carriages across the arches from left to right, white steam trailing behind it. Audio: the chugging engine, wheels clattering over the rails and a long whistle.

To switch tiers, change model and send a ratio from that tier’s list. The inputs section below shows each list.

What are the ways to use Kling 3.0 on Runway Dev?

Kling 3.0 runs on Runway Dev four ways, all from one account:

Kling 3.0 is also available in Model Router, a saved config you send with the request instead of a model ID. You set what to optimize for (cost, quality or latency), a maximum cost per generation and the models allowed, and the router picks one for each request sent to POST /v1/generate/video.

How do you get API access to Kling 3.0?

You get API access to Kling 3.0 with a Runway Dev account and an API key:

1. Create an account at https://dev.runway.com.
2. Create an API key in your project’s dashboard.
3. Add credits to your project’s balance.
4. Store the key in your environment as RUNWAYML_API_SECRET.
5. Send a request with "model": "kling3.0_pro" (or kling3.0_standard, kling3.0_4k) and the X-Runway-Version header to one of its endpoints. The code below is ready to run.

How much does the Kling 3.0 API cost?

The Kling 3.0 API on Runway Dev is billed per second of the video it makes, at a rate set by the tier and by audio: 17 credits ($0.17) per second (With audio) on Kling 3.0 Pro, with lower rates without audio and on Standard.

Kling 3.0 Pro

Kling 3.0 Standard

Kling 3.0 4K

Prices current as of October 22, 2026. 1 credit = $0.01.

How the billing works:

• Only output is billed. Input images add nothing to the price.
• Audio is on unless you turn it off. A request that leaves out audio is billed at the rate with audio. Send "audio": false for the lower rate on Standard and Pro.
• A multi-shot clip is billed for the length of all its shots together, the sum of their duration values.
• A request rejected with a 400 costs nothing. Fields and values are checked before a task is created, so a wrong one isn’t billed.
• A task that fails input moderation (SAFETY.INPUT.*) is still charged. See task failures for what each failure means.

Every rate is also listed on dev.runway.com/pricing and in the docs pricing guide.

What inputs does Kling 3.0 accept?

Kling 3.0 accepts a prompt of up to 2,500 characters, a duration of 3 to 15 seconds, one or two images as keyframes and a list of shots. On Kling 3.0, the model you call sets the resolution, and each tier takes only its own ratio values:

• Kling 3.0 Pro: One of 1920:1080, 1080:1920 or 1440:1440
• Kling 3.0 Standard: One of 1280:720, 720:1280 or 960:960
• Kling 3.0 4K: One of 3840:2160, 2160:3840 or 2880:2880

On POST /v1/text_to_video you send a ratio and a promptText, or a list of shots in providerSettings in place of the prompt.

On POST /v1/image_to_video you set the opening frame, and the closing one if you want it. A single promptImage URL is the first frame. To set both, send a list with one image whose position is first and one whose position is last, and Kling 3.0 generates the motion between them. A last frame on its own is rejected, and the prompt is optional on this endpoint. The clip takes the shape of the first frame, so ratio doesn’t change it, while the tier still sets the resolution.

Fixed camera on the rocky shore at sunrise: the green wave rolls in, curls over and crashes against the dark rock, throwing a tall burst of white spray into the air as foam rushes over the foreground rocks. Audio: the rising roar of the wave, a deep boom as it hits the rock, then hissing foam.

Multi-shot clips go in providerSettings, the object for Kling’s own options, which sits beside audio and cfgScale in the request. Its multiPrompt list takes up to 6 shots, each with its own prompt and duration, and their lengths add up to the clip’s, within 3 to 15 seconds. With multiPrompt, shotType defaults to customize, where each shot’s own prompt is used and promptText isn’t needed; the other value, intelligence, also needs a promptText. This is the shape of the request behind the campfire clip at the top of the page:

{
  "model": "kling3.0_pro",
  "ratio": "1920:1080",
  "providerSettings": {
    "multiPrompt": [
      {
        "prompt": "Locked-off wide shot of a campfire on an empty pebble beach at dusk: …",
        "duration": 5
      },
      {
        "prompt": "Locked-off close shot of the same campfire in its ring of stones: …",
        "duration": 5
      }
    ]
  }
}

Here is every field, by tier and endpoint:

Kling 3.0 Pro

POST /v1/image_to_video

POST /v1/text_to_video

Kling 3.0 Standard

POST /v1/image_to_video

POST /v1/text_to_video

Kling 3.0 4K

POST /v1/image_to_video

POST /v1/text_to_video

Images go in as an HTTPS URL, a runway:// URI from an upload or a data URI; inputs lists sizes and formats. Each table shows what a field accepts on its own. Rules that combine fields are checked when the task is submitted, and the API reference has them in full.

A few rules change what you send:

• ratio sets the shape, and the tier sets the size. A ratio from another tier’s list returns a 400, so change both together.
• Audio is generated unless you turn it off. audio defaults to true; send false for a silent clip, at the lower rate on Standard and Pro.
• cfgScale sets how closely the clip follows the prompt, from 0 for the most freedom to 1 for the closest match. Leaving it out keeps the default.
• Unknown fields return a 400. The request schema is strict, so a field name from Kling’s own API, such as mode, aspect_ratio, sound or image_tail, is rejected rather than ignored.
• Keyframes have a minimum size and a maximum aspect ratio, checked when you submit. See inputs for formats and file sizes.

How do you call Kling 3.0 from curl, Node and Python?

You call Kling 3.0 by sending kling3.0_pro as the model to one of its endpoints. This request makes a clip with sound from text with POST /v1/text_to_video, and the other fields keep their defaults:

curl

curl -X POST https://api.dev.runwayml.com/v1/text_to_video \
  -H "Authorization: Bearer $RUNWAYML_API_SECRET" \
  -H "X-Runway-Version: 2024-11-06" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kling3.0_pro",
    "promptText": "Locked-off wide shot from the bottom of a steep cobbled street in the rain at dusk: a red tram comes down the hill toward the camera on rails set into the wet cobbles, its headlight reflecting on the stones, lit shop windows on both sides. Audio: steady rain, the hum of the tram and its bell ringing twice.",
    "ratio": "1920:1080"
  }'

# The response carries the task id. Poll the task until it finishes:
curl https://api.dev.runwayml.com/v1/tasks/$TASK_ID \
  -H "Authorization: Bearer $RUNWAYML_API_SECRET" \
  -H "X-Runway-Version: 2024-11-06"

Node.js

import RunwayML, { TaskFailedError } from '@runwayml/sdk';

// Reads your API key from RUNWAYML_API_SECRET.
const client = new RunwayML();

try {
  const task = await client.textToVideo
    .create({
      model: 'kling3.0_pro',
      promptText: 'Locked-off wide shot from the bottom of a steep cobbled street in the rain at dusk: a red tram comes down the hill toward the camera on rails set into the wet cobbles, its headlight reflecting on the stones, lit shop windows on both sides. Audio: steady rain, the hum of the tram and its bell ringing twice.',
      ratio: '1920:1080',
    })
    .waitForTaskOutput();
  console.log(task.output);
} catch (error) {
  if (error instanceof TaskFailedError) {
    console.error(error.taskDetails);
  } else {
    throw error;
  }
}

Python

from runwayml import RunwayML, TaskFailedError

# Reads your API key from RUNWAYML_API_SECRET.
client = RunwayML()

try:
    task = client.text_to_video.create(
        model="kling3.0_pro",
        prompt_text="Locked-off wide shot from the bottom of a steep cobbled street in the rain at dusk: a red tram comes down the hill toward the camera on rails set into the wet cobbles, its headlight reflecting on the stones, lit shop windows on both sides. Audio: steady rain, the hum of the tram and its bell ringing twice.",
        ratio="1920:1080",
    ).wait_for_task_output()
    print(task.output)
except TaskFailedError as error:
    print(error.task_details)

ratio is required, so the sample sends its first allowed value. It takes 1920:1080, 1080:1920 or 1440:1440.

To call Standard or 4K, send kling3.0_standard or kling3.0_4k as the model, with a ratio from that tier’s list.

Generation is asynchronous:

• The create request returns a task ID right away, and the video is made in the background.
• Poll GET /v1/tasks/{id} with backoff until the status is SUCCEEDED, FAILED or CANCELLED. THROTTLED means the task is waiting in a queue, not rejected.
• Output URLs are temporary, so download the video when the task succeeds. See outputs.
• The SDKs poll for you. waitForTaskOutput() and wait_for_task_output() raise TaskFailedError with the task’s details when it fails. They also stop waiting after a default timeout while the task keeps running, so for long clips pass a longer timeout or keep polling the task ID.
• To use your own rules instead of one fixed model, send a Model Router’s configId to POST /v1/generate/video in place of the model. Add dryRun to see which model it picks without creating a task.

Why does a Kling 3.0 API request fail?

A request to Kling 3.0 fails with a 400 when a field is wrong, and a task fails with a failure code that names the cause. The common ones:

• A 400 on ratio: the value belongs to another tier, or to another model. Take it from the list of the tier you call.
• A 400 that names mode, aspect_ratio, sound or image_tail: the request carries field names from Kling’s own API. Use model, ratio, audio and a promptImage list.
• A text-to-video request rejected for a missing prompt: Kling 3.0 needs promptText or providerSettings.multiPrompt on POST /v1/text_to_video.
• A multi-shot request rejected for its length: the shots’ duration values must add up to a length within 3 to 15 seconds.
• An image-to-video request with only a last frame: Kling 3.0 needs a first frame. Add one with position set to first.
• SAFETY.INPUT.*: content moderation rejected an input. The task is charged and shouldn’t be retried as is: change the inputs first.
• INTERNAL.BAD_OUTPUT.01: the output failed a quality check, often because of logos, watermarks or text in the input image. Remove them and retry.
• ASSET.INVALID: an input image’s dimensions or format are outside what the model takes. Check it against inputs and fix it before retrying.
• THIRD_PARTY.UNAVAILABLE: the model’s provider didn’t return the video, because of an outage or load. Wait, then retry.
• A bill at the rate with audio: audio defaults to true. Send "audio": false for a silent clip.

What does Runway Dev add when you call Kling 3.0?

Runway Dev serves Kling 3.0 next to Runway’s own models and other labs’ models, behind one API key and one credit balance: you build with a single key and pay a single bill, instead of an account, a key and an invoice per lab.

A coding agent can do the Kling 3.0 integration for you on Runway Dev, end to end. Connect the Runway Dev MCP and the agent works from your live account: the models your project can call with their current prices and input limits, your credit balance and the record behind any task. It writes the integration against what the API accepts today, and when a task fails it looks up the reason and fixes it. The Runway Dev skills show the agent how to integrate with the official SDKs and how to build with models, Model Routers, Recipes and Workflows.

With Workflows, Kling 3.0 Pro or Standard becomes one step of a larger pipeline: chain it with Runway’s own models and other labs’ models, for images, video and audio, and run the whole pipeline with a single API call. Workflows don’t need to be built by a developer. A creative or marketing teammate builds and tests one visually in the Runway app (how Workflows work), then publishes it as an endpoint that your code calls. When the team updates the workflow, your code keeps calling the same endpoint.

FAQ

Is there a Kling API?

There is a Kling API, from two places. Kling sells API access on its own developer platform (checked October 22, 2026), and Runway Dev serves the official Kling 3.0 models through its API, as kling3.0_pro, kling3.0_standard and kling3.0_4k. On Runway Dev you call Kling 3.0 with the same key, SDKs and credit balance as every other model.

How do I get API access to Kling 3.0?

Create a Runway Dev account at dev.runway.com, make an API key and add credits. Then send kling3.0_pro, kling3.0_standard or kling3.0_4k as the model to either of its endpoints: POST /v1/image_to_video and POST /v1/text_to_video. To have a coding agent write the integration instead, connect the Runway Dev MCP and install the Runway Dev skills: the agent builds it from your live account, with the prices and input limits your project has today.

How much does the Kling 3.0 API cost?

On Runway Dev, Kling 3.0 Pro costs 17 credits ($0.17) per second (With audio) and 12 credits ($0.12) per second (Without audio). Kling 3.0 Standard costs 13 credits ($0.13) per second (With audio) and 9 credits ($0.09) per second (Without audio), and Kling 3.0 4K costs 43 credits ($0.43) per second (With or without audio). Input images add no charge, and audio is on unless you turn it off. Prices are current as of October 22, 2026.

Is the Kling 3.0 API on Runway Dev the official model?

Runway Dev’s Kling 3.0 API runs the official Kling 3.0 models from Kling, in all three tiers. You call them with your Runway Dev API key and the model IDs kling3.0_pro, kling3.0_standard and kling3.0_4k, like every other model on Runway Dev.

Can I use Kling 3.0 without writing code?

You can use Kling 3.0 on Runway Dev without writing code yourself. The playground sends a request from a form and gives it back as code, and a coding agent connected to the Runway Dev MCP writes the integration for you. A creative or marketing teammate can also build a workflow around Kling 3.0 in the Runway app and publish it as an endpoint your app calls.

Does the same Runway Dev API key work for Kling 3.0 and other models?

One Runway Dev API key calls Kling 3.0 and every other model your project can use, Runway’s own and other labs’, with the same SDKs, task flow and credit balance. Switching models means changing the model field, or the rules of a Model Router.

What are the Kling 3.0 model IDs on Runway Dev?

The model IDs are kling3.0_pro for Kling 3.0 Pro, kling3.0_standard for Kling 3.0 Standard and kling3.0_4k for Kling 3.0 4K. All three work on the same two endpoints: POST /v1/image_to_video and POST /v1/text_to_video.

What durations and resolutions does the Kling 3.0 API support?

On Runway Dev, Kling 3.0 makes clips of 3 to 15 seconds, set with duration or by the shots of a multi-shot request. The tier sets the resolution: 720p on Standard, 1080p on Pro and the largest size on 4K, each in landscape, portrait or square through ratio.

How do I make a multi-shot video with the Kling 3.0 API?

Send a providerSettings.multiPrompt list with up to 6 shots, each with its own prompt and duration, to POST /v1/text_to_video or POST /v1/image_to_video. The shots’ lengths add up to the clip’s, and the clip is billed for that total.

Does Kling 3.0 generate audio through the API?

Kling 3.0 generates audio with the video by default, on every tier and both endpoints: dialogue, sound effects and ambient sound, written into the prompt. Send audio: false for a silent clip, which costs less on Standard and Pro.

Why did my request to Kling 3.0 fail with SAFETY.INPUT.TEXT?

SAFETY.INPUT.TEXT means content moderation rejected an input of your request; the suffix hints at the prompt but may not match. The task is charged and shouldn’t be retried as is, so change the prompt or inputs before you send it again.

Can I switch from Kling 3.0 to another video model without changing my code?

A Model Router lets you change models without touching your code. Send its configId to POST /v1/generate/video, and change the models it may use, its priority or its cost cap in the router.