# Kling 3.0 API: access, pricing and code

> Is there a Kling API? Get the official Kling 3.0 API on Runway Dev in all three tiers: model IDs, price per second, inputs and code in curl, Node and Python.

Author: Runway · Published: 2026-10-22 · Updated: 2026-10-22 · Source: https://dev.runway.com/learn/kling-3-0-api

## 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.

![A campfire in a ring of stones on a pebble beach at dusk, then a closer shot of the same fire as a log collapses and sparks rise](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/kling-3-0-api-hero-campfire-ae8cf1d0.mp4 'One request, two shots: each has its own prompt and length.')

```text
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](https://dev.runway.com/learn/kling-o3-api), 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:

```text
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.
```

![A steam train pulls red carriages across a stone viaduct in a green valley, made with Kling 3.0 Standard](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/kling-3-0-api-viaduct-standard-6d9cd642.mp4 'Kling 3.0 Standard at 720p, the lowest cost of the three: 13 credits ($0.13) per second (With audio).')

![The same viaduct scene made with Kling 3.0 Pro](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/kling-3-0-api-viaduct-pro-f4a45a12.mp4 'Kling 3.0 Pro at 1080p: 17 credits ($0.17) per second (With audio).')

![The same viaduct scene made with Kling 3.0 4K](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/kling-3-0-api-viaduct-4k-242e2b1a.mp4 'Kling 3.0 4K, the largest size: 43 credits ($0.43) per second (With audio).')

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:

| Way in                                                                                                                 | Best for                                                                                          | What you need                                                   |
| ---------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
| [Playground](https://dev.runway.com/endpoints/image_to_video?modelId=kling3.0_pro)                                     | Trying a prompt, then copying the request as code                                                 | A Runway Dev account                                            |
| [API](https://docs.dev.runwayml.com/guides/using-the-api/) and [SDKs](https://docs.dev.runwayml.com/api-details/sdks/) | Calling Kling 3.0 from your own code                                                              | An API key, plus the Node or Python SDK if you want one         |
| Coding agent                                                                                                           | Having Claude Code, Codex or Cursor build the API integration into your product, tool or pipeline | The Runway Dev MCP and skills, and an API key for live calls    |
| [Workflows](https://dev.runway.com/workflows)                                                                                                | Kling 3.0 Pro or Standard as one step with other models, run with one API call                    | A workflow built in the Runway app and published as an endpoint |

Kling 3.0 is also available in [Model Router](https://dev.runway.com/model-routers), 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

| Option | Credits | USD |
| --- | --- | --- |
| Without audio | 12 credits per second | $0.12 per second |
| With audio | 17 credits per second | $0.17 per second |

### Kling 3.0 Standard

| Option | Credits | USD |
| --- | --- | --- |
| Without audio | 9 credits per second | $0.09 per second |
| With audio | 13 credits per second | $0.13 per second |

### Kling 3.0 4K

| Option | Credits | USD |
| --- | --- | --- |
| With or without audio | 43 credits per second | $0.43 per second |

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](https://docs.dev.runwayml.com/errors/task-failures) for what each failure means.

Every rate is also listed on [dev.runway.com/pricing](https://dev.runway.com/pricing) and in the [docs pricing guide](https://docs.dev.runwayml.com/guides/pricing/).

## 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.

![A tall green wave rising behind a dark rock outcrop at sunrise](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/images/kling-3-0-api/keyframes-wave-first-d3efeae4.jpg 'First frame') ![The same rocks as the wave crashes and white spray bursts over the outcrop](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/images/kling-3-0-api/keyframes-wave-last-71723fde.jpg 'Last frame')

![A wave rolls in and crashes against a dark rock at sunrise, throwing up a tall burst of white spray](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/kling-3-0-api-keyframes-wave-d9e6872e.mp4 'Kling 3.0 generates the motion between the first and the last frame.')

```text
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:

```json
{
  "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`

| Field | Accepts |
| --- | --- |
| `model` (required) | `kling3.0_pro` |
| `audio` | `true` or `false`. Default `true` |
| `providerSettings` | See the API reference |
| `cfgScale` | Number from 0 to 1. Default `0.5` |
| `promptText` | Text, 2 to 2,500 characters |
| `promptImage` (required) | One image, or a list of up to 2 images, each with an optional `position` of `first` or `last` |
| `ratio` | One of `1920:1080`, `1080:1920` or `1440:1440` |
| `duration` | Whole number from 3 to 15 |

#### `POST /v1/text_to_video`

| Field | Accepts |
| --- | --- |
| `model` (required) | `kling3.0_pro` |
| `audio` | `true` or `false`. Default `true` |
| `providerSettings` | See the API reference |
| `cfgScale` | Number from 0 to 1. Default `0.5` |
| `promptText` | Text, 2 to 2,500 characters |
| `ratio` (required) | One of `1920:1080`, `1080:1920` or `1440:1440` |
| `duration` | Whole number from 3 to 15 |

### Kling 3.0 Standard

#### `POST /v1/image_to_video`

| Field | Accepts |
| --- | --- |
| `model` (required) | `kling3.0_standard` |
| `audio` | `true` or `false`. Default `true` |
| `providerSettings` | See the API reference |
| `cfgScale` | Number from 0 to 1. Default `0.5` |
| `promptText` | Text, 2 to 2,500 characters |
| `promptImage` (required) | One image, or a list of up to 2 images, each with an optional `position` of `first` or `last` |
| `ratio` | One of `1280:720`, `720:1280` or `960:960` |
| `duration` | Whole number from 3 to 15 |

#### `POST /v1/text_to_video`

| Field | Accepts |
| --- | --- |
| `model` (required) | `kling3.0_standard` |
| `audio` | `true` or `false`. Default `true` |
| `providerSettings` | See the API reference |
| `cfgScale` | Number from 0 to 1. Default `0.5` |
| `promptText` | Text, 2 to 2,500 characters |
| `ratio` (required) | One of `1280:720`, `720:1280` or `960:960` |
| `duration` | Whole number from 3 to 15 |

### Kling 3.0 4K

#### `POST /v1/image_to_video`

| Field | Accepts |
| --- | --- |
| `model` (required) | `kling3.0_4k` |
| `audio` | `true` or `false`. Default `true` |
| `providerSettings` | See the API reference |
| `cfgScale` | Number from 0 to 1. Default `0.5` |
| `promptText` | Text, 2 to 2,500 characters |
| `promptImage` (required) | One image, or a list of up to 2 images, each with an optional `position` of `first` or `last` |
| `ratio` | One of `3840:2160`, `2160:3840` or `2880:2880` |
| `duration` | Whole number from 3 to 15 |

#### `POST /v1/text_to_video`

| Field | Accepts |
| --- | --- |
| `model` (required) | `kling3.0_4k` |
| `audio` | `true` or `false`. Default `true` |
| `providerSettings` | See the API reference |
| `cfgScale` | Number from 0 to 1. Default `0.5` |
| `promptText` | Text, 2 to 2,500 characters |
| `ratio` (required) | One of `3840:2160`, `2160:3840` or `2880:2880` |
| `duration` | Whole number from 3 to 15 |

Images go in as an HTTPS URL, a `runway://` URI from an [upload](https://docs.dev.runwayml.com/assets/uploads) or a data URI; [inputs](https://docs.dev.runwayml.com/assets/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](https://docs.dev.runwayml.com/api/) 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](https://docs.dev.runwayml.com/assets/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**

```bash
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**

```javascript
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**

```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`.

![A red tram comes down a steep cobbled street toward the camera in the rain at dusk, its headlight reflecting on the wet stones](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/kling-3-0-api-code-output-c5f613bf.mp4 'The request above, as Kling 3.0 Pro returns it.')

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](https://docs.dev.runwayml.com/assets/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](https://dev.runway.com/learn/choosing-the-right-model)'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](https://docs.dev.runwayml.com/assets/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](https://dev.runway.com/models/catalog), 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](https://docs.dev.runwayml.com/guides/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](https://github.com/runwayml/skills) show the agent how to integrate with the official SDKs and how to build with models, Model Routers, Recipes and Workflows.

With [Workflows](https://dev.runway.com/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](https://dev.runway.com/models/catalog), 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](https://app.runwayml.com/workflows) ([how Workflows work](https://help.runwayml.com/hc/en-us/articles/45763528999699-Introduction-to-Workflows)), then [publishes it as an endpoint](https://help.runwayml.com/hc/en-us/articles/50682960972947-Publishing-a-Workflow-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](https://kling.ai/dev) (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.