# Seedance 2.5 extend: how to make 1–5 minute videos with the API

By SeedRouter · Published 2026-10-03 · Updated 2026-10-03

Seedance 2.5 renders at most 30 seconds per request, so a one to five minute video is built from segments: generate the first clip, then send it back as a reference video with `omni_reference_task_type: "extend"` and the model continues it from its last frame. Each extend call returns only the new part, so you join the segments end to end. A test run on October 3, 2026 chained one 15-second clip and three 15-second extends at 480p into a 60-second video; the joins were close to invisible and each segment followed its own prompt. The catch is cost: an extend request is billed for the seconds of the reference video as well as the seconds it generates.

Facts about the request come from the [Seedance 2.5 API reference](https://seedrouter.ai/docs/seedance-2-5). Prices come from the live rate table further down, checked on October 3, 2026.

<video preload="none" poster="https://static.seedrouter.ai/media/blog/2026-10-03-seedance-2-5-extend-long-video/seedance-2-5-extend-60s-poster.jpg" src="https://static.seedrouter.ai/media/blog/2026-10-03-seedance-2-5-extend-long-video/seedance-2-5-extend-60s.mp4" width="854" height="480" style="{ width: '100%', height: 'auto' }" />

*The 60-second test video: one 15-second clip and three 15-second extends at 480p, joined end to end with ffmpeg.*

## Can Seedance 2.5 make a one minute video in one request?

No. `duration` accepts 4 to 30 seconds (or `-1` to let the model choose), so a single request ends at 30 seconds. Anything longer is a chain of requests. Seedance 2.5 doubled the clip length of Seedance 2.0 and added the ability to edit and extend a video you supply; the [Seedance 2.5 vs 2.0 guide](https://seedrouter.ai/blog/seedance-2-5-vs-2-0) covers the other differences. Seedance 2.0 cannot extend a video, so this method is specific to Seedance 2.5.

## How does Seedance 2.5 extend work?

You send a text prompt and one reference video, and set `omni_reference_task_type` to `extend`. The model continues the reference video past its last frame and follows the prompt for what happens next. Three rules from the API reference apply:

* `ratio` must be `adaptive` or left out. The output keeps the reference video's frame.
* The reference video goes in `content` as a `video_url` item with the role `reference_video`, by URL only.
* Reference videos must be MP4 or MOV, 2 to 30 seconds each and at most 30 seconds in total, 24 to 60 FPS, at most 200 MB.

What the test run showed about the output:

| Question                                                        | Result on October 3, 2026                                                                                                          |
| --------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| Does the result include the reference video?                    | No. Each extend returned only the new 15 seconds.                                                                                  |
| Does the first new frame match the last old frame?              | Nearly. Before and after each join the boat, the light and the framing matched closely.                                            |
| Does each segment follow its own prompt?                        | Yes. The scene moved from a forest stream to a meadow river, under a stone bridge and onto a lake at sunset, as each prompt asked. |
| Can the previous output be used as the next reference directly? | Yes. The output URL went straight into the next request, with no re-upload.                                                        |

Each segment generates its own soundtrack. The audio at the joins was not checked by ear, so listen to the cuts before you publish.

## What does an extend request look like?

The first clip is an ordinary text-to-video request:

```json
{
  "model": "dreamina-seedance-2-5",
  "content": [{"type": "text", "text": "A small red paper boat drifts down a winding forest stream at golden hour, slow tracking shot from behind"}],
  "resolution": "480p",
  "ratio": "16:9",
  "duration": 15
}
```

Every later segment sends the previous result back as the reference video:

```json
{
  "model": "dreamina-seedance-2-5",
  "content": [
    {"type": "text", "text": "Continue the shot: the paper boat drifts out of the forest into a wide meadow river, the camera keeps tracking from behind"},
    {"type": "video_url", "video_url": {"url": "https://your-storage.example/segment-1.mp4"}, "role": "reference_video"}
  ],
  "omni_reference_task_type": "extend",
  "resolution": "480p",
  "ratio": "adaptive",
  "duration": 15
}
```

Both go to `POST https://api.seedrouter.ai/v1/contents/generations/tasks`, which returns a task id. Poll `GET https://api.seedrouter.ai/v1/contents/generations/tasks/{id}` until `status` is `succeeded`, then read `content.video_url`. Writing the next prompt as "Continue the shot: …" and repeating the camera move kept the motion consistent across the joins.

## How do I chain extend calls into a long video?

Generate, extend from the newest segment, repeat, then join the files. This Python script does it with the requests library and ffmpeg:

```python
import os, subprocess, time
import requests

API = "https://api.seedrouter.ai/v1/contents/generations/tasks"
HEADERS = {"Authorization": f"Bearer {os.environ['SEEDROUTER_API_KEY']}"}

def run(body):
    task_id = requests.post(API, json=body, headers=HEADERS).json()["id"]
    while True:
        time.sleep(15)
        task = requests.get(f"{API}/{task_id}", headers=HEADERS).json()
        if task["status"] == "succeeded":
            return task["content"]["video_url"]
        if task["status"] in ("failed", "expired"):
            raise RuntimeError(task)

prompts = [
    "A small red paper boat drifts down a winding forest stream at golden hour, slow tracking shot from behind",
    "Continue the shot: the paper boat drifts out of the forest into a wide meadow river, the camera keeps tracking from behind",
    "Continue the shot: the paper boat floats under an old stone bridge covered in ivy, warm sunset light",
    "Continue the shot: the paper boat drifts onto a calm lake at sunset, the camera slowly rises and pulls back",
]

urls = [run({"model": "dreamina-seedance-2-5", "content": [{"type": "text", "text": prompts[0]}],
             "resolution": "480p", "ratio": "16:9", "duration": 15})]
for prompt in prompts[1:]:
    urls.append(run({"model": "dreamina-seedance-2-5",
                     "content": [{"type": "text", "text": prompt},
                                 {"type": "video_url", "video_url": {"url": urls[-1]}, "role": "reference_video"}],
                     "omni_reference_task_type": "extend",
                     "resolution": "480p", "ratio": "adaptive", "duration": 15}))

with open("list.txt", "w") as f:
    for i, url in enumerate(urls):
        name = f"part{i}.mp4"
        with open(name, "wb") as out:
            out.write(requests.get(url).content)
        f.write(f"file '{name}'\n")
subprocess.run(["ffmpeg", "-f", "concat", "-safe", "0", "-i", "list.txt", "-c", "copy", "long.mp4"], check=True)
```

All segments share the same codec, resolution and frame rate, so ffmpeg joins them without re-encoding. For five minutes at 15 seconds per step, add prompts until the list has 20 entries; the mechanics do not change. The test run covered 60 seconds, so for longer chains look at every few segments for drift in the subject or the color before you continue.

## What does a minute of Seedance 2.5 video cost with extend?

Seedance 2.5 bills video tokens, and an extend request pays for the reference video too:

```text
video tokens = (output seconds + reference video seconds) × width × height × 24 / 1024
```

A request with a reference video uses the lower "with reference video" rate for all of its tokens. Here are the current Seedance 2.5 rates:

### Seedance 2.5

Current rates are temporarily unavailable. No price estimate is provided; unavailable rates must not be interpreted as free usage.

Measured token counts at 480p, 16:9, from the test run:

| Segment                              | Seconds billed           | Tokens reported |
| ------------------------------------ | ------------------------ | --------------- |
| First clip, no reference             | 15 output                | 144,512         |
| Each extend, 15-second reference     | 15 reference + 15 output | 288,225         |
| 60-second video (1 clip + 3 extends) | —                        | 1,009,187       |

To price a minute, multiply the first clip's tokens by the "without reference" rate and each extend's tokens by the "with reference" rate. At the rates above, an extended second costs about 1.2 times a fresh second at 480p and 720p, because the request pays for twice the seconds at the lower rate. Token counts scale with resolution: one second at 16:9 is 9,607.5 tokens at 480p, 21,600 at 720p and 48,600 at 1080p, so the same 60-second chain is about 2.25 times the tokens at 720p and about 5 times at 1080p. The [Seedance API pricing guide](https://seedrouter.ai/blog/seedance-api-pricing) explains the rates and the token formula in more detail.

## How can I keep long Seedance videos cheaper?

* **Draft at 480p.** Find the story and the prompts at 480p, then render the final chain at a higher resolution.
* **Keep the reference short.** Every reference second is billed. The test run used the whole previous 15-second segment; a shorter clip from the end of the previous segment bills fewer seconds, but its effect on continuity was not tested.
* **Use longer steps.** A 30-second extend from a 30-second reference adds 30 seconds per request, so a five minute video needs fewer requests. The billed seconds per added second stay the same, but there are fewer prompts to write and fewer joins to check.
* **Stop a bad chain early.** If a segment drifts, regenerate that segment instead of extending from it. Failed and expired tasks are not charged.

## What can go wrong when extending a Seedance video?

* **Real faces.** Reference images and videos that contain real human faces are not supported by the model. Generated characters are fine; the [real person error guide](https://seedrouter.ai/blog/seedance-real-person-error) explains the rule.
* **Wrong ratio.** The API reference requires `ratio: "adaptive"` or no `ratio` for extend; do not carry `16:9` over from the first clip's request.
* **Reference limits.** A reference video outside 2–30 seconds, above 200 MB or outside 24–60 FPS fails before generation, with a message naming the rule, and is not charged.
* **Drift over many steps.** Each segment only sees the previous one, so details can wander over a long chain. Repeat the key description of the subject in every prompt.

## Frequently asked questions

### Does Seedance 2.5 extend return the whole video?

No. It returns only the continuation, so join the segments yourself. In the October 3, 2026 test, each 15-second extend returned a 15-second file.

### Is the reference video billed when extending?

Yes. The token count includes the reference video's seconds as well as the output seconds, at the lower "with reference video" rate.

### Can I extend a video that Seedance did not make?

Yes. Any MP4 or MOV that meets the reference video limits can be extended. Host it at a public URL and send it as a `reference_video`.

### How long can a Seedance 2.5 video get with extend?

Each extend is an independent request that adds up to 30 seconds, so the length depends on how many you chain. The test reached 60 seconds; longer chains follow the same steps, with more chances for drift.

### Can Seedance 2.0 extend a video?

No. Editing and extending a supplied video are Seedance 2.5 features. Seedance 2.0 only generates new clips.

## Build your first long video

Run the chain on [Seedance 2.5](https://seedrouter.ai/models/seedance-2-5) with a SeedRouter key. The [Seedance 2.5 API reference](https://seedrouter.ai/docs/seedance-2-5) lists every parameter, the [Seedance API guide](https://seedrouter.ai/blog/seedance-api) covers keys and polling, and the [Seedance 2.5 prompt guide](https://seedrouter.ai/blog/seedance-2-5-prompt-guide) helps with the prompt for each segment. SeedRouter is pay as you go: top up once, credits never expire, and failed requests are not charged.