Seedance 2.5 API — Parameters, Modes & Billing

ByteDance Seedance 2.5 — async video generation up to 30 seconds with native audio on reAPI. Full parameter reference, request modes, and billing dimensions.

ByteDance's next-generation async video model, live on reAPI. Seedance 2.5 turns text, photos, clips, or audio into video up to 30 seconds long, with generated speech, sound effects and music. Like the rest of the Seedance family, mode is implicit: which media fields you set (prompt, image_urls, image_with_roles, video_urls, audio_urls) decides whether the request runs as text-to-video, image-to-video, first/last-frame transition, or reference-driven generation. See pricing on the model page.

Quick example

curl https://reapi.ai/api/v1/videos/generations \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "doubao-seedance-2.5-face",
    "prompt": "A kitten yawning at the camera, cinematic warm tones",
    "resolution": "720p",
    "size": "16:9",
    "duration": 5
  }'

import requests

resp = requests.post(
    "https://reapi.ai/api/v1/videos/generations",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "model": "doubao-seedance-2.5-face",
        "prompt": "A kitten yawning at the camera, cinematic warm tones",
        "resolution": "720p",
        "size": "16:9",
        "duration": 5,
    },
    timeout=30,
)
print(resp.json())

const r = await fetch("https://reapi.ai/api/v1/videos/generations", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "doubao-seedance-2.5-face",
    prompt: "A kitten yawning at the camera, cinematic warm tones",
    resolution: "720p",
    size: "16:9",
    duration: 5,
  }),
});
console.log(await r.json());

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    body, _ := json.Marshal(map[string]any{
        "model":      "doubao-seedance-2.5-face",
        "prompt":     "A kitten yawning at the camera, cinematic warm tones",
        "resolution": "720p",
        "size":       "16:9",
        "duration":   5,
    })
    req, _ := http.NewRequest("POST",
        "https://reapi.ai/api/v1/videos/generations", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    out, _ := io.ReadAll(resp.Body)
    fmt.Println(string(out))
}

Authentication

Every call needs a Bearer token. Generate keys at reapi.ai/settings/apikeys.

Authorization: Bearer YOUR_API_KEY

Keys carry the active workspace's billing scope — there is no separate project header.

Endpoint

POST /api/v1/videos/generations
GET  /api/v1/tasks/{id}

Submission is async. The POST returns immediately with a task_id; the task endpoint returns the same envelope until completion. Polling does not consume credits.

Request body

Mode is implicit — which media fields you set decides text-to-video, image-to-video, first/last-frame, or reference-driven generation. Audio-only reference (just audio_urls) is supported, and reference images / videos may contain real people.

Field	Type	Default	Notes
`model`	string	—	`doubao-seedance-2.5-face`. Required.
`prompt`	string	—	Describe the video. Required, 3–20000 chars. Wrap spoken lines in double quotes to steer the generated speech.
`duration`	integer	`5`	Output length in seconds, `4`–`30`.
`size`	string	`adaptive`	`16:9` / `9:16` / `1:1` / `4:3` / `3:4` / `21:9` / `adaptive`. First/last-frame and edit-style requests keep the input's aspect ratio.
`resolution`	string	`720p`	`480p` / `720p`.
`generate_audio`	boolean	`true`	Generate synced speech, sound effects and background music (mono).
`output_format`	string	`mp4`	`mp4` / `mov`. `mov` uses high color-precision encoding for pro post-production; some players can't play it.
`return_last_frame`	boolean	`false`	Return `output.last_frame_url` for continuous chaining.
`tools`	object[]	—	`[{ "type": "web_search" }]` to let the model query the web.
`image_urls`	string[]	—	Up to 30 reference images (jpeg / png / webp / bmp / tiff / gif / heic / heif, each < 30 MB). Public HTTP(S) URLs.
`image_with_roles`	object[]	—	First frame alone, or first + last frame (`{ url, role }`, role `first_frame` / `last_frame`, ≤ 2; the two images may be identical).
`video_urls`	string[]	—	Up to 10 reference clips (mp4 / mov, 480p–4K, each ≤ 200 MB), each 2–30 s, combined ≤ 30 s.
`audio_urls`	string[]	—	Up to 10 reference audio tracks (wav / mp3, each ≤ 15 MB), each 2–30 s, combined ≤ 30 s.

Constraints enforced before submit: image_urls and image_with_roles are mutually exclusive, and image_with_roles cannot be combined with video_urls or audio_urls. seed is not supported by Seedance 2.5.

No data: URIs. reAPI rejects base64 inputs platform-wide — every URL field must be a public HTTP(S) URL. Upload to your own object storage (S3, R2, OSS, …) and pass the URL.

Response envelope

Submit and poll share the same shape — only status and output fill in over time.

{
  "id": "task_018f5a3a1b6e7d9f8c2b4d6e8f0a2c4e",
  "model": "doubao-seedance-2.5-face",
  "status": "completed",
  "created_at": 1735000000,
  "output": {
    "video_urls": ["https://cdn.reapi.ai/media/tasks/.../0.mp4"],
    "last_frame_url": "https://cdn.reapi.ai/media/tasks/.../0.png"
  },
  "error": null
}

Poll GET /api/v1/tasks/{id} (see the Tasks reference) until status === "completed". output.video_urls holds the generated video URL (mp4, or mov when output_format: "mov" was set). output.last_frame_url is present when the request set return_last_frame: true.

Pricing

Seedance 2.5 bills per-second, scaled by resolution and reference mode — the same dimensions as the rest of the Seedance family:

credits = ceil(per_second_usd × billable_seconds × 1000)

where 1 credit = $0.001. Two rate tiers exist per resolution: the base tier, and a lower per-second tier that applies when the request uploads reference videos (video_urls). On that tier billable_seconds covers the source clips as well as the output — reAPI probes the real duration of every reference video server-side, and the provider enforces a minimum billable window of ⌈5/3 × duration⌉ seconds for video-input requests, whichever is larger. Image and audio references don't add billable seconds.

Current per-second rates are published on the model page — that table is dynamic and always reflects the current rate. Failed jobs are refunded automatically.

doubao-seedance-2.5-face