# Seedance 2.5 API: access, pricing and code

> Get the official Seedance 2.5 API on Runway Dev: model ID, endpoints, price per second, draft mode and code in curl, Node and Python.

Author: Runway · Published: 2026-10-19 · Updated: 2026-10-19 · Source: https://dev.runway.com/learn/seedance-2-5-api

## Summary

Runway Dev gives you the official Seedance 2.5 API, available since its API launch day. Seedance 2.5 is ByteDance's video generation model for longer, multi-shot clips with audio, made from text, images, video or audio, and it can extend or edit clips you already have. One generation holds several connected shots directed from the prompt, and draft mode renders a preview before the final video. This page covers access, pricing, inputs and code, and how your coding agent can build the integration for you.

## What is Seedance 2.5?

Seedance 2.5 is ByteDance's video generation model for longer, multi-shot clips. It turns text, images, video and audio, alone or combined, into clips of up to 30 seconds with audio generated in the same pass, and it can extend or edit a clip you already have.

ByteDance [announced it on July 31, 2026](https://seed.bytedance.com/en/blog/one-take-creation-flexible-referencing-introducing-seedance-2-5) with API access to follow, and Runway Dev offered the official model the day that API became generally available, [August 7, 2026](https://docs.dev.runwayml.com/api-details/api_changelog/).

One generation can hold several connected shots, with the camera directed from the prompt, and draft mode makes a lower-cost preview before you pay for the final video.

![A barista in a small café sets a cup under the espresso machine, espresso pours into it, then she slides the cup across the counter to a customer and speaks.](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/seedance-2-5-api-cafe-61a071a7.mp4 'One text-to-video request: three shots in one café, a line of dialogue and the sound of the room, made with Seedance 2.5.')

```text
Three shots in a small café at opening time, warm morning light, handheld. One counter with an espresso machine on it and a window behind it on the left, all in the same place in every shot. Shot 1: wide from the doorway, a barista in a grey apron sets a cup under the espresso machine. Shot 2: close-up, espresso pours into the cup. Shot 3: medium across the counter, she slides the cup to a customer and says: "Careful, it's hot." Audio: the grinder, the espresso machine hissing, cups on saucers, her line spoken clearly with natural lip sync.
```

## What are the ways to use Seedance 2.5 on Runway Dev?

Seedance 2.5 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=seedance2_5) | Trying a prompt, then copying the request as code                                                 | A Runway Dev account                                            |
| API and SDKs                                                                      | Calling Seedance 2.5 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)                                                           | Seedance 2.5 as one step with other models, run with one API call                                 | A workflow built in the Runway app and published as an endpoint |

Seedance 2.5 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 Seedance 2.5?

You get API access to Seedance 2.5 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": "seedance2_5"` and the `X-Runway-Version` header to one of its endpoints. The code below is ready to run.

## How much does the Seedance 2.5 API cost?

The Seedance 2.5 API on Runway Dev is billed per second of the video it makes, at a rate set by the output resolution: 68 credits ($0.68) per second at 1080p, with lower rates below it.

| Resolution | Credits | USD | Video references |
| --- | --- | --- | --- |
| 480p | 20 credits per second | $0.20 per second | +10 credits ($0.10) per second of input |
| 720p | 30 credits per second | $0.30 per second | +15 credits ($0.15) per second of input |
| 1080p | 68 credits per second | $0.68 per second | +34 credits ($0.34) per second of input |

- Minimum 80 credits ($0.80) per generation.
- Image and audio references add no charge.
- A 5-second clip costs 100 credits ($1.00) at 480p, 150 credits ($1.50) at 720p or 340 credits ($3.40) at 1080p, before video references.

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

How the billing works:

- **Input and reference videos are billed per second**, at the rate of the output's resolution, up to the combined length the API accepts.
- **A `duration` of `auto` is billed as 30 seconds up front**, and what the clip doesn't use is refunded once it finishes.
- **Draft mode bills twice**: the preview at 20 credits ($0.20) per second at 480p, and the enhanced video at 68 credits ($0.68) per second at 1080p for the same length. The preview's charge stays as it was.
- **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.

![Draft](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/seedance-2-5-api-moss-draft-zoom-32bbce88.mp4 'One draft-mode request, zoomed in on the same detail: drag the divider to compare the draft with the enhanced video.') ![Enhanced](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/seedance-2-5-api-moss-enhanced-zoom-29f5e081.mp4)

```text
Macro shot, locked-off camera: rain falls on a moss-covered stone wall, droplets bead on every strand of moss and run down the cracks in the stone, a small snail crossing slowly through the frame. Soft overcast light, sharp detail. Audio: steady rain, drips, a distant roll of thunder.
```

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

## What inputs does Seedance 2.5 accept?

Seedance 2.5 accepts a prompt of up to 15,000 characters, a duration of 4 to 30 seconds or `auto`, and images, videos and audio as inputs and references. Each endpoint uses them its own way.

On `POST /v1/image_to_video` you set the first and last frames, or pass images as references instead, never both in one request. A single `promptImage` URL is the first frame. For keyframes, send a list with a `position` of `first`, and `last` if you want a closing frame. For references, send a list with no `position` on any image: that is also the only mode that takes `referenceAudio`, which needs a `promptText`.

On `POST /v1/text_to_video` a request takes up to 30 images, 10 videos and 10 audio clips as references, to steer a subject, a motion or a sound. References can stand in for the prompt: a request needs a prompt or at least one reference image, video or audio clip.

On `POST /v1/video_to_video`, `mode` decides what happens to your clip. `reference` (the default) uses it as a reference for a new video. `extend` continues it with new shots that keep its characters and setting, and `edit` changes it in place, for example replacing the background or changing the camera's perspective. Both need a `promptText` and keep the input's aspect ratio, so they take no `ratio`. With `edit`, `duration` must be `auto`.

Here is every field, by endpoint:

### `POST /v1/image_to_video`

| Field | Accepts |
| --- | --- |
| `model` (required) | `seedance2_5` |
| `promptImage` (required) | One image, or a list of images, each with an optional `position` of `first` or `last` |
| `promptText` | Text, 1 to 15,000 characters |
| `audio` | `true` or `false`. Default `true` |
| `seed` | Whole number from 0 to 4,294,967,295 |
| `outputFormat` | One of `mp4` or `mov` |
| `duration` | Whole number from 4 to 30, or `auto` |
| `ratio` | One of `992:432`, `854:480`, `752:560`, `640:640`, `560:752`, `480:854`, `1470:630`, `1280:720`, `1112:834`, `960:960`, `834:1112`, `720:1280`, `2206:946`, `1920:1080`, `1664:1248`, `1440:1440`, `1248:1664` or `1080:1920` |
| `referenceAudio` | A list of up to 10 audio clips |
| `draft` | `true` or `false` |

### `POST /v1/text_to_video`

| Field | Accepts |
| --- | --- |
| `model` (required) | `seedance2_5` |
| `promptText` | Text, 1 to 15,000 characters |
| `audio` | `true` or `false` |
| `seed` | Whole number from 0 to 4,294,967,295 |
| `outputFormat` | One of `mp4` or `mov` |
| `duration` | Whole number from 4 to 30, or `auto` |
| `ratio` | One of `992:432`, `854:480`, `752:560`, `640:640`, `560:752`, `480:854`, `1470:630`, `1280:720`, `1112:834`, `960:960`, `834:1112`, `720:1280`, `2206:946`, `1920:1080`, `1664:1248`, `1440:1440`, `1248:1664` or `1080:1920` |
| `references` | A list of up to 30 images |
| `referenceVideos` | A list of up to 10 videos |
| `referenceAudio` | A list of up to 10 audio clips |
| `draft` | `true` or `false` |
| `draftTaskId` | A task ID |

### `POST /v1/video_to_video`

| Field | Accepts |
| --- | --- |
| `model` (required) | `seedance2_5` |
| `promptVideo` (required) | One video |
| `promptText` | Text, 1 to 15,000 characters |
| `audio` | `true` or `false`. Default `true` |
| `seed` | Whole number from 0 to 4,294,967,295 |
| `outputFormat` | One of `mp4` or `mov` |
| `mode` | One of `reference`, `extend` or `edit`. Default `reference` |
| `duration` | Whole number from 4 to 30, or `auto` |
| `ratio` | One of `992:432`, `854:480`, `752:560`, `640:640`, `560:752`, `480:854`, `1470:630`, `1280:720`, `1112:834`, `960:960`, `834:1112`, `720:1280`, `2206:946`, `1920:1080`, `1664:1248`, `1440:1440`, `1248:1664` or `1080:1920` |
| `references` | A list of up to 30 images |
| `referenceVideos` | A list of up to 9 videos |
| `referenceAudio` | A list of up to 10 audio clips |
| `draft` | `true` or `false` |

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

One more rule changes what you send:

- **Draft mode makes a preview before the final video.** Send `draft: true` and the task returns a lower-resolution preview at your aspect ratio. To enhance a preview you like, call `POST /v1/text_to_video` with only `model` and `draftTaskId`: any other field is rejected, and the preview has to be your own, finished and inside the enhancement window in the [draft mode docs](https://docs.dev.runwayml.com/guides/models#seedance-25-draft-mode).

![A florist's wooden workbench with loose ranunculus, eucalyptus and white tulip stems, a roll of brown paper, twine and shears.](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/images/seedance-2-5-api/keyframe-first-c617e8e1.jpg 'First frame') ![The same workbench with one finished bouquet wrapped in brown paper and tied with twine, trimmed stem ends beside it.](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/images/seedance-2-5-api/keyframe-last-f69cfbb8.jpg 'Last frame')

![A florist's hands gather loose ranunculus, eucalyptus and tulip stems on a wooden bench, trim them and wrap them in brown paper into a tied bouquet.](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/seedance-2-5-api-florist-keyframes-a81c9fac.mp4 'Image-to-video between a first and a last frame: Seedance 2.5 fills in the hands at work between the two stills.')

```text
A florist's hands gather the loose stems, trim them with the shears and wrap them in the brown paper, finishing on the tied bouquet. Locked-off camera, soft window light. Audio: stems snipping, paper crinkling, the quiet of a small shop.
```

![A trail runner with short dark curly hair in a rust-orange top and black shorts against a light grey wall.](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/images/seedance-2-5-api/reference-runner-2f90b15c.jpg '@Image1') ![A matte sage-green insulated water bottle with a cork cap on a light grey surface.](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/images/seedance-2-5-api/reference-bottle-61035591.jpg '@Image2') ![A gravel trail along a green coastal cliff top at sunrise, mist over the sea below.](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/images/seedance-2-5-api/reference-trail-5739ac1e.jpg '@Image3')

![A trail runner in a rust-orange top runs along a coastal cliff path at sunrise, stops and drinks from a sage-green bottle, then looks out at the sea.](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/seedance-2-5-api-trail-runner-references-b3d3b702.mp4 'Three references in one text-to-video request, a person, a product and a place, kept the same across three shots.')

```text
@Image1 runs along the cliff trail from @Image3 at sunrise, slows at the edge and drinks from the bottle in @Image2. Shot 1: wide tracking shot beside her as she runs, the sea far below. Shot 2: close-up as she lifts the bottle and drinks. Shot 3: medium, she lowers the bottle and looks out at the water, breathing hard. Keep her face, clothes and the bottle the same in every shot. Audio: footsteps on gravel, wind, waves below, her breathing.
```

## How do you call Seedance 2.5 from curl, Node and Python?

You call Seedance 2.5 by sending `seedance2_5` as the model to one of its endpoints. This request animates a still image with `POST /v1/image_to_video`, and the other fields keep their defaults:

**curl**

```bash
curl -X POST https://api.dev.runwayml.com/v1/image_to_video \
  -H "Authorization: Bearer $RUNWAYML_API_SECRET" \
  -H "X-Runway-Version: 2024-11-06" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance2_5",
    "promptImage": "https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/images/campaign-localizer/product-shot-b4fce78b.jpg",
    "promptText": "Locked-off camera, the glass chess knight never moves. Inside it, storm clouds drift and thin bolts of lightning flicker on and off, lighting the glass from within",
    "duration": 4
  }'

# 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.imageToVideo
    .create({
      model: 'seedance2_5',
      promptImage: 'https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/images/campaign-localizer/product-shot-b4fce78b.jpg',
      promptText: 'Locked-off camera, the glass chess knight never moves. Inside it, storm clouds drift and thin bolts of lightning flicker on and off, lighting the glass from within',
      duration: 4,
    })
    .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.image_to_video.create(
        model="seedance2_5",
        prompt_image="https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/images/campaign-localizer/product-shot-b4fce78b.jpg",
        prompt_text="Locked-off camera, the glass chess knight never moves. Inside it, storm clouds drift and thin bolts of lightning flicker on and off, lighting the glass from within",
        duration=4,
    ).wait_for_task_output()
    print(task.output)
except TaskFailedError as error:
    print(error.task_details)
```

![A glass chess knight stands still on its pedestal while storm clouds drift inside it and thin bolts of lightning flash through the glass.](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/seedance-2-5-api-glass-knight-lightning-141c6202.mp4 'Made from the image and prompt in the request above.')

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

A Seedance 2.5 task fails with a failure code that names the cause. 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.
- **An `Invalid video resolution` message**: an input or reference video is smaller than the minimum in [inputs](https://docs.dev.runwayml.com/assets/inputs). Export it at a higher resolution.
- **`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` or `duration`**: values copied from another model, [Seedance 2.0](https://dev.runway.com/learn/seedance-2-0-api) included, can be outside Seedance 2.5's lists. Take them from the inputs above.
- **An enhance request rejected**: it carried fields besides `model` and `draftTaskId`, or the preview is outside the enhancement window.
- **An output link that stopped working**: output URLs expire. Download the video when the task succeeds.

## What does Runway Dev add when you call Seedance 2.5?

Runway Dev serves Seedance 2.5 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 Seedance 2.5 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), Seedance 2.5 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 Seedance 2.5?**

Create a Runway Dev account at dev.runway.com, make an API key and add credits. Then send `seedance2_5` 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.

**How much does the Seedance 2.5 API cost?**

On Runway Dev, Seedance 2.5 costs 68 credits ($0.68) per second at 1080p, 30 credits ($0.30) per second at 720p and 20 credits ($0.20) per second at 480p, with a minimum of 80 credits ($0.80) per generation. Input and reference videos add a per-second charge, and reference images and audio add none. Prices are current as of October 22, 2026.

**Is the Seedance 2.5 API on Runway Dev the official model?**

Runway Dev's Seedance 2.5 API runs the official Seedance 2.5 model from ByteDance, offered since the day its API became generally available. You call it with your Runway Dev API key and the model ID `seedance2_5`, like every other model on Runway Dev.

**Can I use Seedance 2.5 without writing code?**

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

**Does the same Runway Dev API key work for Seedance 2.5 and other models?**

One Runway Dev API key calls Seedance 2.5 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 is the Seedance 2.5 model ID on Runway Dev?**

The model ID is `seedance2_5`, and it is the same on all of its endpoints: `POST /v1/image_to_video`, `POST /v1/text_to_video` and `POST /v1/video_to_video`.

**How long can a Seedance 2.5 video be, and at what resolutions?**

A Seedance 2.5 clip on Runway Dev runs 4 to 30 seconds, or set `duration` to `auto` and the model picks the length. It comes out at 480p, 720p and 1080p, chosen through the `ratio` you send.

**How many references can Seedance 2.5 use through the API?**

Seedance 2.5 takes up to 30 images, 10 videos and 10 audio clips as references on `POST /v1/text_to_video`. On `POST /v1/video_to_video` it takes up to 30 images, 9 videos and 10 audio clips, alongside the clip you send. On `POST /v1/image_to_video`, up to 30 reference images go in `promptImage` as a list with no `position` (a single URL is read as the first frame), and the request can add up to 10 audio clips.

**What is Seedance 2.5 draft mode, and how is it billed?**

Draft mode makes a Seedance 2.5 preview first and the final video only when you ask for it. Send `draft: true`, then enhance the preview with a `POST /v1/text_to_video` request that carries only `model` and `draftTaskId`. The preview is billed at 20 credits ($0.20) per second at 480p and the enhanced video at 68 credits ($0.68) per second at 1080p, as two separate charges.

**Can Seedance 2.5 edit or extend an existing video through the API?**

Seedance 2.5 extends and edits clips on `POST /v1/video_to_video`. Set `mode` to `extend` to continue a clip or `edit` to change it in place, and describe the change in `promptText`.

**Why did my Seedance 2.5 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 Seedance 2.5 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.

**How do I write prompts for Seedance 2.5?**

Runway's [Seedance 2.5 prompt guide](https://runway.com/resources/seedance-2-5-prompt-guide) covers how to structure a Seedance 2.5 prompt.