# Kling O3 (Kling 3.0 Omni) API: access, pricing and code

> Get the official Kling O3 (Kling 3.0 Omni) API on Runway Dev: edit a video or generate one, with model IDs, price per second, inputs and code.

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

## Summary

Runway Dev gives you the official Kling O3 API, also called Kling 3.0 Omni, in two main tiers, Kling O3 Pro and Kling O3 4K, plus a smaller Standard tier. Kling O3 is Kling's omni video model: it edits a video from a text prompt, and it generates clips with sound from text or from a first frame and reference images. The tiers take the same inputs at different output sizes. This page covers access, pricing, inputs and code, and how your coding agent can build the integration for you.

## What is Kling O3?

Kling O3, also called Kling 3.0 Omni, is Kling's video model for editing and generating in one model. Send it a clip and a prompt, and it rewrites the clip (the light, the weather, the style or what is in the frame) while the framing and the motion stay as they were. Send it text, or a first frame with reference images, and it makes a new clip of 3 to 15 seconds, with sound generated in the same pass and, if you ask for it, several shots in one clip.

![Clip sent](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/kling-o3-api-hero-tram-source-b37d78bb.mp4 'One video-to-video request turns a sunny afternoon into blue hour, with the same tram, framing, motion and sound. Drag the divider to compare the clip sent with the edit.') ![Kling O3 edit](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/kling-o3-api-hero-tram-edit-46981ca1.mp4)

```text
Change <<<video_1>>> to blue hour just after sunset: a deep blue sky, warm light glowing in the windows of the houses, the street lamps and the tram headlights on, their light reflecting on the cobblestones. Keep the street, the houses, the tram and its motion exactly the same.
```

## What is the difference between Kling O3 and Kling 3.0?

Kling O3 and Kling 3.0 both generate video with sound on Runway Dev, from a text prompt on `POST /v1/text_to_video` or from a first frame on `POST /v1/image_to_video`, with the same tiers, durations and multi-shot prompts. What sets Kling O3 apart is editing: it takes a clip you already have and rewrites it from a prompt on `POST /v1/video_to_video`, keeping its framing, motion and sound. Kling 3.0 has no video-to-video endpoint.

| On Runway Dev                                    | Kling O3                                         | Kling 3.0                 |
| ------------------------------------------------ | ------------------------------------------------ | ------------------------- |
| Edit a video (`POST /v1/video_to_video`)         | Yes, keeping the clip's sound                    | No                        |
| Generate from text (`POST /v1/text_to_video`)    | Yes                                              | Yes                       |
| Generate from images (`POST /v1/image_to_video`) | A first frame, a last frame and reference images | A first and a last frame  |
| `cfgScale`                                       | Not taken                                        | Taken                     |
| Price with audio off                             | The same rate as with audio                      | Lower on Standard and Pro |

For new clips without reference images, the [Kling 3.0 API page](https://dev.runway.com/learn/kling-3-0-api) covers that model. Kling O3 is the one to call when the job starts from a video you already have.

## What are the ways to use Kling O3 on Runway Dev?

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

| Way in                                                                                                                 | Best for                                                                                          | What you need                                                   |
| ---------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
| [Playground](https://dev.runway.com/endpoints/video_to_video?modelId=klingO3_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 O3 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)                                                                                                | A Kling O3 edit as one step with other models, run with one API call                              | A workflow built in the Runway app and published as an endpoint |

Kling O3 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 O3?

You get API access to Kling O3 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": "klingO3_pro"` (or `klingO3_4k`, `klingO3_standard`) and the `X-Runway-Version` header to one of its endpoints. The code below is ready to run.

## How much does the Kling O3 API cost?

The Kling O3 API on Runway Dev is billed per second of video, at one rate per tier whether you edit a clip or generate one, with or without audio: 17 credits ($0.17) per second on Kling O3 Pro and 43 credits ($0.43) per second on Kling O3 4K. An edit is billed by the length of the clip you send, because Kling O3 returns the whole clip edited. Kling O3 Standard costs 13 credits ($0.13) per second.

### Kling O3 Pro

| Credits | USD |
| --- | --- |
| 17 credits per second | $0.17 per second |

### Kling O3 4K

| Credits | USD |
| --- | --- |
| 43 credits per second | $0.43 per second |

### Kling O3 Standard

| Credits | USD |
| --- | --- |
| 13 credits per second | $0.13 per second |

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

![A slow aerial drift over water-filled rice terraces at sunrise, mist in the valley below and thin streams of water spilling from one terrace to the next](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/kling-o3-api-price-terraces-4k-258025fd.mp4 'Kling O3 4K, with its sound, at 43 credits ($0.43) per second.')

```text
Slow aerial drift over water-filled rice terraces on a hillside at sunrise, mist lying in the valley below, the terraces reflecting the pink and gold sky, thin streams of water spilling from one terrace to the next. No people, no text. Audio: trickling water, morning birds, a soft wind.
```

How the billing works:

- **Audio doesn't change the price.** Every tier bills the same rate whether `audio` is on or off.
- **An edit bills the length of its source.** A video-to-video request takes no `duration`: the clip in `promptVideo` sets how many seconds are billed.
- **Input images add nothing to the price.** Only the seconds of video Kling O3 returns are 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 in the [docs pricing guide](https://docs.dev.runwayml.com/guides/pricing/).

## What inputs does Kling O3 accept?

Kling O3 accepts a prompt of up to 2,500 characters and makes clips of 3 to 15 seconds. Images and video go in as a first frame, references or the clip to edit, and each endpoint uses them its own way.

On `POST /v1/video_to_video` Kling O3 edits the clip in `promptVideo` from a `promptText`, which is required, and returns the whole clip at its own length and framing, so the request takes no `duration` or `ratio`. The clip can run up to 10 seconds, with each side at least 720 pixels. Add up to 4 reference images for something the edit should bring in. In the prompt, `<<<video_1>>>` stands for the clip and `<<<image_1>>>` for the first reference image. The edit keeps the clip's own sound unless you send `keepOriginalSound: false` in `providerSettings`, and the request takes no `audio` field.

On `POST /v1/image_to_video` the clip starts from the image in `promptImage`, which needs a `first` frame and can add a `last` one. `references` adds images of a subject, an object or a style to bring into the clip, up to 7 images in all, keyframes included. The prompt names each image as `<<<image_1>>>`, `<<<image_2>>>` and so on, in the order the request sends them: the first frame, the last frame if there is one, then the references. The clip takes the first frame's shape.

![A grassy clifftop above the sea on a windy afternoon, long grass and wildflowers bent by the wind](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/images/kling-o3-api/refs-cliff-a7f50079.jpg 'First frame, image_1') ![A diamond-shaped kite with orange, teal and cream panels and a tail of orange and teal ribbon bows](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/images/kling-o3-api/refs-kite-4de46da3.jpg 'Reference, image_2')

![The orange, teal and cream kite flies in the wind above the clifftop, its ribbon tail streaming behind it as the long grass bends](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/kling-o3-api-refs-kite-clip-eabf7c15.mp4 'A first frame and one reference image: the clip starts on the clifftop and brings in the kite with its panels and colors.')

```text
The kite from <<<image_2>>> flies above the clifftop in <<<image_1>>>, held on a taut thin string that runs down out of the bottom of the frame. The wind tugs it up and to the side and its ribbon tail streams out behind it, while the long grass and wildflowers bend the same way. The camera tilts up slightly to keep the kite in frame. Audio: strong gusts of wind, the kite fabric fluttering, waves breaking far below.
```

On `POST /v1/text_to_video` the prompt alone makes the clip, at the `ratio` you pick from the tier's list.

**The tier sets the size, and `ratio` picks the shape.** Kling O3 Pro takes One of `1920:1080`, `1080:1920` or `1440:1440`, Kling O3 4K takes One of `3840:2160`, `2160:3840` or `2880:2880` and Kling O3 Standard takes One of `1280:720`, `720:1280` or `960:960`. A `ratio` copied from another tier fails validation.

**`providerSettings` carries Kling's own options:**

- **`multiPrompt`** is a list of shots, each with its own `prompt` and `duration`, that Kling O3 makes into one multi-shot clip on text-to-video and image-to-video. The shot durations add up to the clip's length, within 3 to 15 seconds, and `promptText` becomes optional. It doesn't combine with a `last` frame, and video-to-video doesn't take it.
- **`shotType`** is `customize` by default with `multiPrompt`, which follows your list of shots. `intelligence` has Kling plan the shots from `promptText`, which is then required.
- **`keepOriginalSound`**, on video-to-video only, keeps the sound of the clip you edit. It defaults to `true`.

Here is every field, by tier and endpoint:

### Kling O3 Pro

#### `POST /v1/image_to_video`

| Field | Accepts |
| --- | --- |
| `model` (required) | `klingO3_pro` |
| `audio` | `true` or `false`. Default `true` |
| `providerSettings` | See the API reference |
| `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 |
| `references` | One image, or a list of images |

#### `POST /v1/text_to_video`

| Field | Accepts |
| --- | --- |
| `model` (required) | `klingO3_pro` |
| `audio` | `true` or `false`. Default `true` |
| `providerSettings` | See the API reference |
| `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 |

#### `POST /v1/video_to_video`

| Field | Accepts |
| --- | --- |
| `model` (required) | `klingO3_pro` |
| `providerSettings` | See the API reference |
| `promptText` (required) | Text, 2 to 2,500 characters |
| `promptVideo` (required) | One video |
| `references` | One image, or a list of images |

### Kling O3 4K

#### `POST /v1/image_to_video`

| Field | Accepts |
| --- | --- |
| `model` (required) | `klingO3_4k` |
| `audio` | `true` or `false`. Default `true` |
| `providerSettings` | See the API reference |
| `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 |
| `references` | One image, or a list of images |

#### `POST /v1/text_to_video`

| Field | Accepts |
| --- | --- |
| `model` (required) | `klingO3_4k` |
| `audio` | `true` or `false`. Default `true` |
| `providerSettings` | See the API reference |
| `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 |

#### `POST /v1/video_to_video`

| Field | Accepts |
| --- | --- |
| `model` (required) | `klingO3_4k` |
| `providerSettings` | See the API reference |
| `promptText` (required) | Text, 2 to 2,500 characters |
| `promptVideo` (required) | One video |
| `references` | One image, or a list of images |

### Kling O3 Standard

#### `POST /v1/image_to_video`

| Field | Accepts |
| --- | --- |
| `model` (required) | `klingO3_standard` |
| `audio` | `true` or `false`. Default `true` |
| `providerSettings` | See the API reference |
| `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 |
| `references` | One image, or a list of images |

#### `POST /v1/text_to_video`

| Field | Accepts |
| --- | --- |
| `model` (required) | `klingO3_standard` |
| `audio` | `true` or `false`. Default `true` |
| `providerSettings` | See the API reference |
| `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 |

#### `POST /v1/video_to_video`

| Field | Accepts |
| --- | --- |
| `model` (required) | `klingO3_standard` |
| `providerSettings` | See the API reference |
| `promptText` (required) | Text, 2 to 2,500 characters |
| `promptVideo` (required) | One video |
| `references` | One image, or a list of images |

Images and videos 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.

Two more rules change what you send:

- **Reference images take no `position`.** Keyframes go in `promptImage`, and a `position` in `references` fails validation.
- **Audio is generated unless you turn it off.** On text-to-video and image-to-video, `audio` defaults to `true`; send `false` for a silent clip. The price stays the same.

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

You call Kling O3 by sending `klingO3_pro` as the model to one of its endpoints. This request restyles a clip with `POST /v1/video_to_video`, and the other fields keep their defaults:

**curl**

```bash
curl -X POST https://api.dev.runwayml.com/v1/video_to_video \
  -H "Authorization: Bearer $RUNWAYML_API_SECRET" \
  -H "X-Runway-Version: 2024-11-06" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "klingO3_pro",
    "promptText": "Restyle <<<video_1>>> as a hand-painted watercolor animation on textured paper, with soft washes of color and visible brush strokes. Keep the composition, the boats and their motion the same.",
    "promptVideo": "https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/kling-o3-api-code-harbor-source-7fde11f5.mp4"
  }'

# 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.videoToVideo
    .create({
      model: 'klingO3_pro',
      promptText: 'Restyle <<<video_1>>> as a hand-painted watercolor animation on textured paper, with soft washes of color and visible brush strokes. Keep the composition, the boats and their motion the same.',
      promptVideo: 'https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/kling-o3-api-code-harbor-source-7fde11f5.mp4',
    })
    .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.video_to_video.create(
        model="klingO3_pro",
        prompt_text="Restyle <<<video_1>>> as a hand-painted watercolor animation on textured paper, with soft washes of color and visible brush strokes. Keep the composition, the boats and their motion the same.",
        prompt_video="https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/kling-o3-api-code-harbor-source-7fde11f5.mp4",
    ).wait_for_task_output()
    print(task.output)
except TaskFailedError as error:
    print(error.task_details)
```

![Clip sent](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/kling-o3-api-code-harbor-source-7fde11f5.mp4 'The request above, as Kling O3 returns it: drag the divider to compare the clip in promptVideo with the watercolor edit.') ![Kling O3 edit](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/kling-o3-api-code-harbor-edit-ed39b03d.mp4)

To edit on another tier, send `klingO3_4k` or `klingO3_standard` as the model. The rest of the request stays the same.

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 O3 API request fail?

A Kling O3 task fails with a failure code that names the cause, and a request that breaks an input rule is rejected before a task is made. The common ones:

- **`SAFETY.INPUT.*`**: content moderation rejected an input. The suffix hints at which one but may not match. The task is charged and shouldn't be retried as is: change the inputs first.
- **`SAFETY.OUTPUT.*`**: the generated video was rejected by moderation. Change the prompt or references before you try again.
- **`ASSET.INVALID`**: an input file's dimensions, duration or another property is outside what the model takes. Check it against [inputs](https://docs.dev.runwayml.com/assets/inputs) and fix it before retrying.
- **A `promptVideo` rejected for its length or size**: the clip to edit runs over 10 seconds, or a side is under 720 pixels. Trim it or export it at a larger size.
- **`INTERNAL.BAD_OUTPUT.01`**: the output failed a quality check, often because of logos, watermarks or text in the input images. Remove them and retry.
- **`THIRD_PARTY.UNAVAILABLE`**: the model's provider didn't return the video, because of an outage or load. Wait, then retry.
- **A validation error on `ratio`**: the ratio belongs to another tier or another model. Pick one from the tier's list above.
- **A request rejected for a missing prompt**: text-to-video and image-to-video need a `promptText` or a `multiPrompt`, and video-to-video always needs a `promptText`.
- **Too many images on image-to-video**: the first frame, the last frame and the references count together, up to 7.
- **An output link that stopped working**: output URLs expire. Download the video when the task succeeds.

## What does Runway Dev add when you call Kling O3?

Runway Dev serves Kling O3 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 O3 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), a Kling O3 edit 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

**How do I get API access to Kling O3?**

Create a Runway Dev account at dev.runway.com, make an API key and add credits. Then send `klingO3_pro`, `klingO3_4k` or `klingO3_standard` as the model to any of its endpoints: `POST /v1/image_to_video`, `POST /v1/text_to_video` and `POST /v1/video_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.

**Can Kling O3 edit a video through an API?**

Kling O3 edits a video through `POST /v1/video_to_video` on Runway Dev. Send the clip as `promptVideo` and describe the change in `promptText`; Kling O3 returns the whole clip edited, at its own length and framing, with its original sound kept by default. Reference images can bring a subject or an object into the edit.

**How much does the Kling O3 API cost?**

On Runway Dev, Kling O3 Pro costs 17 credits ($0.17) per second, Kling O3 4K 43 credits ($0.43) per second and Kling O3 Standard 13 credits ($0.13) per second, with or without audio. An edit is billed by the length of the clip you send. Prices are current as of October 22, 2026.

**What is the difference between Kling O3 and Kling 3.0?**

Kling O3 and Kling 3.0 both generate video with sound from text or a first frame on Runway Dev, in the same tiers, durations and multi-shot prompts. Kling O3 adds video editing on `POST /v1/video_to_video`, which Kling 3.0 doesn't offer, and takes reference images next to the first frame. Kling 3.0 Standard and Pro have a lower rate with audio off, while Kling O3 bills one rate per tier.

**Is the Kling O3 API on Runway Dev the official model?**

Runway Dev's Kling O3 API runs the official Kling 3.0 Omni model from Kling, in all three tiers. You call it with your Runway Dev API key and the model IDs `klingO3_pro`, `klingO3_4k` and `klingO3_standard`, like every other model on Runway Dev.

**Can I use Kling O3 without writing code?**

You can use Kling O3 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 O3 in the Runway app and publish it as an endpoint your app calls.

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

One Runway Dev API key calls Kling O3 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 O3 model IDs on Runway Dev?**

The model IDs are `klingO3_pro` for Kling O3 Pro, `klingO3_4k` for Kling O3 4K and `klingO3_standard` for Kling O3 Standard. Each works on the same three endpoints: `POST /v1/image_to_video`, `POST /v1/text_to_video` and `POST /v1/video_to_video`.

**How long can a Kling O3 video be, and at what sizes?**

A Kling O3 clip generated on Runway Dev runs 3 to 15 seconds, and an edit keeps the length of the clip you send. The tier sets the size: Kling O3 Pro renders One of `1920:1080`, `1080:1920` or `1440:1440`, and Kling O3 4K One of `3840:2160`, `2160:3840` or `2880:2880`.

**Does Kling O3 generate audio through the API?**

Kling O3 generates audio with the video by default on text-to-video and image-to-video; send `audio: false` for a silent clip. An edit keeps the sound of the clip you send instead, unless `keepOriginalSound` is `false`.

**Can Kling O3 make multi-shot videos through the API?**

Kling O3 makes a multi-shot clip when you send `multiPrompt` in `providerSettings`: a list of shots, each with its own prompt and duration, on text-to-video or image-to-video. Set `shotType` to `intelligence` to have Kling plan the shots from your `promptText` instead.

**Why did my Kling O3 request 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 O3 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.