Seedance 2.5

Introduction

Most video models stop at five to eight seconds. To reach thirty seconds you generate six short clips and fight to hold the same subject, light, and grade across all of them, then hide the seams with cuts. The warm light in the first clip drifts cool by the fourth, and the reel reads as shot across two afternoons.

Seedance 2.5 returns up to thirty seconds of continuous video in one call. Because the whole runtime renders as one piece, the identity, the light, and the grade carry through the full clip. The one-take below follows a single subject across three connected beats without a cut.

The cyclist, her jacket, and the dusk light hold from second one to second thirty. This guide covers how to write a thirty-second brief, when to run it as one take versus a multi-shot passage, how to pin continuity across the runtime, and how to reach past thirty seconds with extension.

The request

A long-form request is any call with a longer duration. The rest is the standard shape: a prompt, and a resolution or a width and height.

import { createClient } from '@runware/sdk'

const client = await createClient({ apiKey: process.env.RUNWARE_API_KEY })
await client.connect()

const [result] = await client.run({
  model: 'bytedance:seedance@2.5',
  positivePrompt: 'A cinematic one-take film in one continuous 30-second shot following a cyclist through a city at dusk, no cuts. Beat 1 (0-10s): she rides down a tree-lined street. Beat 2 (10-20s): she crosses a plaza as the streetlights come on. Beat 3 (20-30s): she stops at an overlook and looks out over the lit city. Consistent warm-to-blue dusk light and smooth continuous tracking.',
  resolution: '720p',
  duration: 30,
  deliveryMethod: 'async'
})

import asyncio
import os

from runware import Runware


async def main():
    async with Runware(api_key=os.environ["RUNWARE_API_KEY"]) as client:
        results = await client.run({
            "model": "bytedance:seedance@2.5",
            "positivePrompt": "A cinematic one-take film in one continuous 30-second shot following a cyclist through a city at dusk, no cuts. Beat 1 (0-10s): she rides down a tree-lined street. Beat 2 (10-20s): she crosses a plaza as the streetlights come on. Beat 3 (20-30s): she stops at an overlook and looks out over the lit city. Consistent warm-to-blue dusk light and smooth continuous tracking.",
            "resolution": "720p",
            "duration": 30,
            "deliveryMethod": "async"
        })


asyncio.run(main())

curl https://api.runware.ai/v1 \
  -H "Authorization: Bearer $RUNWARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[
    {
      "taskType": "videoInference",
      "taskUUID": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
      "model": "bytedance:seedance@2.5",
      "positivePrompt": "A cinematic one-take film in one continuous 30-second shot following a cyclist through a city at dusk, no cuts. Beat 1 (0-10s): she rides down a tree-lined street. Beat 2 (10-20s): she crosses a plaza as the streetlights come on. Beat 3 (20-30s): she stops at an overlook and looks out over the lit city. Consistent warm-to-blue dusk light and smooth continuous tracking.",
      "resolution": "720p",
      "duration": 30,
      "deliveryMethod": "async"
    }
  ]'

runware run bytedance:seedance@2.5 \
  positivePrompt="A cinematic one-take film in one continuous 30-second shot following a cyclist through a city at dusk, no cuts. Beat 1 (0-10s): she rides down a tree-lined street. Beat 2 (10-20s): she crosses a plaza as the streetlights come on. Beat 3 (20-30s): she stops at an overlook and looks out over the lit city. Consistent warm-to-blue dusk light and smooth continuous tracking." \
  resolution=720p \
  duration=30 \
  deliveryMethod=async

{
  "taskType": "videoInference",
  "taskUUID": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "model": "bytedance:seedance@2.5",
  "positivePrompt": "A cinematic one-take film in one continuous 30-second shot following a cyclist through a city at dusk, no cuts. Beat 1 (0-10s): she rides down a tree-lined street. Beat 2 (10-20s): she crosses a plaza as the streetlights come on. Beat 3 (20-30s): she stops at an overlook and looks out over the lit city. Consistent warm-to-blue dusk light and smooth continuous tracking.",
  "resolution": "720p",
  "duration": 30,
  "deliveryMethod": "async"
}

[
  {
    "taskType": "videoInference",
    "taskUUID": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "videoUUID": "c1d2e3f4-a5b6-7890-cdef-1234567890ab",
    "videoURL": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/c1d2e3f4-a5b6-7890-cdef-1234567890ab.mp4"
  }
]

• duration runs from 4 to 30 seconds. Thirty is the reason to reach for this model over a shorter-form generator.
• resolution renders 16:9 at 480p or 720p, or set a width and height pair for another aspect. 720p is the ceiling.
• Audio is on by default and costs real render time on a thirty-second clip. Turn settings.audio off while you iterate on structure, and back on for the delivery render.

Why thirty seconds in one call

Stitching six five-second clips is the fallback when a model caps at eight. It works for a montage and breaks for anything that needs continuity. Each clip solves its own lighting, its own subject, and its own grade, so a warm three o'clock light comes back as a cooler four o'clock light two clips later, and a reel of one model in one suit is really six models in six subtly different suits. The seams show wherever one shot butts against the next.

A single thirty-second call solves that because the whole runtime is one solve. The frame at second twenty-nine belongs to the same render as the frame at second one, so the manual grade pass in post shrinks from mandatory to optional.

The three-beat structure

A thirty-second brief written as one long paragraph reads to the model as one long blur. The structure that gives you control is Setup, Development, Resolution: three named beats, each with an explicit time range and its own action. The model treats each beat as an anchor and paces the runtime around them.

Name the time ranges. Writing Beat 1 (0-10s): hands the model a rhythm to hit. Without the ranges it guesses how to distribute the action and usually front-loads, spending eighteen seconds on the first beat and rushing the last two. With them, the pacing lands close to what you asked for. The continuity contract at the end names what holds across all three beats: the light logic, the camera behavior, and the fact that there are no cuts.

Multi-shot storytelling in one clip

A multi-shot passage in the same call is the alternative to a single take. Single-shot briefs work when the subject's own motion carries the runtime. Multi-shot briefs work when the story needs to change perspective. You write each shot as its own beat, and the model cuts between them.

The reel cuts twice inside one call. The wide shot lays out the bay, the mid tracking puts the viewer at water level, and the hero close delivers the arrival. Because it renders as one piece, the light logic and the palette progress smoothly across all three shots. The pattern is the three-beat shape written in shot language: each Shot N opens with a size cue like Wide establishing or Mid tracking, and the word Cut to at the top of shots two and three is what tells the model to break the frame there rather than run the camera through.

Continuity across the runtime

A closing continuity contract is what holds a thirty-second frame together. A subject that reads as the same person from end to end, and a light source that keeps one colour temperature across a walkthrough, do not come free. They come from one or two closing lines that pin the constants.

The walkthrough runs four beats in one take, and the light is pinned with a single line: "consistent warm late-afternoon light throughout", so there is no drift from afternoon to noon between the foyer and the bathroom. The camera pace is pinned the same way, and the tone with it. Everything left unpinned is fair game for the model to reinterpret, and small drift compounds over thirty seconds. The pin belongs in one closing clause, not repeated inside every beat, where the model reads it as noise. One line that names what stays constant is what does the work.

Extending past thirty seconds

Thirty seconds is the single-pass ceiling, not the length ceiling. Extension continues an existing clip through inputs.video, and chaining extensions is how a clip reaches a minute or more. It comes in three shapes: forward from the last frame, backward ending at the first frame, and a bridge generated between two clips. Below, an eight-second dawn shot is extended forward by six seconds into one fourteen-second clip.

Extension shares inputs.video with editing, and the prompt decides which happens: an extend verb like continue, extend forward, or extend the story versus an edit verb. Duration on an extension is the number of seconds to add (an integer), or "auto", unlike an edit which is "auto" only.

Tips

1. Write three beats, not one paragraph. Break the runtime into Setup, Development, and Resolution with explicit time ranges (Beat 1 (0-10s):), and each beat becomes an anchor the model can land.

2. State the continuity contract at the end. Name what stays constant across the runtime, the palette, the light logic, the camera pace, in one closing clause. Repeating it inside every beat reads as noise.

3. Match the beat count to the runtime. Two beats fit five to eight seconds, three fit thirty, and four fit thirty only when one runs short. Cramming five beats into thirty rushes the pacing.

4. Prefer a single take when the subject drives the runtime. A cyclist crossing a city or a car tracing a coastline carries thirty seconds on its own motion, and the frame stays coherent because it never cuts.

5. Reach for multi-shot when the perspective has to change. Write each shot as its own beat with a size cue, and Cut to at the boundary tells the model to break the frame.

6. Turn audio off while you iterate. Native audio costs real render time on a thirty-second clip. Iterate silent on structure and pace, then re-enable it for delivery.

7. Chain extensions to go long, and stitch as you go. Each extension returns only its new segment, so concatenate onto the source and feed the result back as the next inputs.video to build a multi-minute piece.

8. Match duration to the story. Thirty seconds fits a mini-narrative or a walkthrough. A single reaction or a static packshot in motion reads better at five to eight, covered in the prompting guide.