Seedance 2.5

Seedance 2.5 (bytedance/seedance-2.5) is ByteDance’s video model for long-form stories: multimodal references (images, clips, audio), a first and a last frame, native sound, and a reproducibility seed. Generation is asynchronous: POST /v1/videos returns a job, then you poll the status and download the mp4.

Parameters

Field	Description
`model`	`bytedance/seedance-2.5` (or the short `seedance-2.5`)
`prompt`	Scene description, required; up to 30 000 characters
`seconds`	Any integer from 4 to 30; defaults to 4. The special value `-1` — edit mode (see below)
`size`	A `WxH` size from the table below; defaults to `1280x720`
`input_reference`	Image-to-video: one image as the starting frame, `{"image_url": "data:image/...;base64,..."}` — `data:` URLs only
`input_references`	Reference-to-video: 1 to 30 images in an array, also `data:` URLs only
`input_video`	Video reference: `{"video_url": "https://..."}` or a `data:` URL. Motion, a dance or choreography is carried over to the character in your images. One clip in the API (up to 10 in the dashboard and bot). With `seconds: "-1"` — edit mode: the model re-shoots the clip itself following the prompt
`input_audio`	Audio reference: `{"audio_url": "https://..."}` or a `data:` URL. The soundtrack follows the track’s rhythm and mood, but it is not a copy of the input. One track in the API (up to 10 in the dashboard and bot)
`seed`	Reproducibility seed: an integer 0…2147483647. The same prompt with the same seed produces the same clip; without it the upstream picks a random one

Eighteen allowed sizes — six aspect ratios in three resolutions:

Aspect	480p	720p	1080p
`16:9`	`852x480`	`1280x720`	`1920x1080`
`9:16`	`480x852`	`720x1280`	`1080x1920`
`1:1`	`480x480`	`720x720`	`1080x1080`
`4:3`	`640x480`	`960x720`	`1440x1080`
`3:4`	`480x640`	`720x960`	`1080x1440`
`21:9`	`1120x480`	`1680x720`	`2520x1080`

A value outside the list returns 400 with the allowed options — check the sizes field in the catalog if in doubt.

Input rules

Images (input_reference, input_references): data: URLs only, up to 30 references, no extra charge for them.
Clip (input_video): mp4 or mov, 2 to 30 seconds (longer is trimmed), a frame of at least 407 696 pixels (720×576 for example), a link up to 50 MB or data: up to 40 MB. Combines with input_references; not with input_reference (the first frame).
Audio (input_audio): mp3, wav, m4a, aac, ogg, opus or flac; 1 to 30 seconds (longer is trimmed), up to 20 MB.
Links must be https on a public host; redirects are not followed. We download the file before creating the job, so a bad file returns 400 with the reason right away.
In the prompt the clip is @video1, the images are @image1, @image2…, the audio is @audio1.
First and last frame (a transition): available in the web dashboard and bot; the API does not have a separate end-frame field yet.

Examples

import requests

job = requests.post(
    "https://api.mixen.ai/v1/videos",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "model": "bytedance/seedance-2.5",
        "prompt": "A drone circles a lighthouse on a rocky shore at sunrise, spray from the waves",
        "seconds": "8",
        "size": "1920x1080",
    },
).json()
print(job["id"], job["status"])

curl https://api.mixen.ai/v1/videos \
  -H "Authorization: Bearer $MIXEN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "bytedance/seedance-2.5",
    "prompt": "A drone circles a lighthouse on a rocky shore at sunrise, spray from the waves",
    "seconds": "8",
    "size": "1920x1080"
  }'

Image-to-video with an image reference and a prompt

The image goes as a single data: URL string — external links are not accepted. Full cycle: read the file, base64-encode, start the job, poll until done, download the mp4:

Python
cURL

import base64
import time
import requests

with open("portrait.jpg", "rb") as f:
    img = "data:image/jpeg;base64," + base64.b64encode(f.read()).decode()

job = requests.post(
    "https://api.mixen.ai/v1/videos",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "model": "bytedance/seedance-2.5",
        "prompt": "The portrait comes alive: a look into the camera, a light smile, hair moving, soft light",
        "seconds": "10",
        "size": "720x1280",
        "input_reference": {"image_url": img},
    },
).json()
print(job["id"], job["status"])

while True:
    time.sleep(7)
    st = requests.get(f"https://api.mixen.ai/v1/videos/{job['id']}",
                      headers={"Authorization": f"Bearer {API_KEY}"}).json()
    if st["status"] in ("completed", "failed"):
        print(st["status"], st.get("error"))
        break

if st["status"] == "completed":
    with requests.get(f"https://api.mixen.ai/v1/videos/{job['id']}/content",
                      headers={"Authorization": f"Bearer {API_KEY}"},
                      stream=True) as r:
        r.raise_for_status()
        with open("out.mp4", "wb") as f:
            for chunk in r.iter_content(1 << 16):
                f.write(chunk)
    print("saved out.mp4")

# 1) image → a data: URL
IMG=$(base64 -w0 portrait.jpg)

# 2) start the job
JOB=$(curl -s https://api.mixen.ai/v1/videos \
  -H "Authorization: Bearer $MIXEN_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"model\": \"bytedance/seedance-2.5\",
    \"prompt\": \"The portrait comes alive: a look into the camera, a light smile, hair moving, soft light\",
    \"seconds\": \"10\",
    \"size\": \"720x1280\",
    \"input_reference\": {\"image_url\": \"data:image/jpeg;base64,$IMG\"}
  }" | python3 -c 'import json,sys; print(json.load(sys.stdin)["id"])')

# 3) poll until completed and download
curl -s https://api.mixen.ai/v1/videos/$JOB -H "Authorization: Bearer $MIXEN_API_KEY"
curl -L https://api.mixen.ai/v1/videos/$JOB/content \
  -H "Authorization: Bearer $MIXEN_API_KEY" -o out.mp4

Reference-to-video with several images

From one to thirty images — the model assembles the scene while keeping the characters and style of the references:

{
  "model": "bytedance/seedance-2.5",
  "prompt": "The girl from @image1 walks along the street from @image2, evening lights",
  "seconds": "6",
  "size": "1280x720",
  "input_references": [
    "data:image/png;base64,iVBORw0...",
    "data:image/png;base64,iVBORw0..."
  ]
}

Images + clip + audio in one request

Motion comes from the clip, the character from the images, the sound follows the track:

{
  "model": "bytedance/seedance-2.5",
  "prompt": "The girl from @image1 repeats the dance from @video1 to the beat of @audio1, a neon hall",
  "seconds": "10",
  "size": "720x1280",
  "input_references": ["data:image/jpeg;base64,/9j/4AAQ..."],
  "input_video": {"video_url": "https://example.com/dance.mp4"},
  "input_audio": {"audio_url": "https://example.com/beat.mp3"}
}

Editing an existing video (v2v)

Re-shoot YOUR OWN clip from a prompt — no images needed: "seconds": "-1" plus a single input_video. The model re-renders the same clip with the prompt’s changes: duration and aspect ratio are inherited, the output renders at 720p, the sound is kept. size is ignored in this mode; references and frames are not accepted:

{
  "model": "bytedance/seedance-2.5",
  "prompt": "Add golden sunset light, warm cinematic grade",
  "seconds": "-1",
  "input_video": {"video_url": "https://example.com/clip.mp4"}
}

Poll and download as usual (GET /v1/videos/{id} → GET /v1/videos/{id}/content). In the dashboard the clip is normalised to ≤15 s, in the API to ≤30 s; you pay for the re-shoot (720p output × length) plus the input clip in tokens — POST /videos/price returns the exact amount beforehand.

Then as usual: GET /v1/videos/{id} every 5–10 seconds until completed, then GET /v1/videos/{id}/content for the mp4. For the full cycle see the video guide.

Pricing

Billed per second, the rate depends on the resolution: 480p — 15.65 ₽ per second, 720p — 33.66 ₽, 1080p — 82.80 ₽. Video and audio references are billed on top of the output seconds — the amount depends on the clip’s frame and length and on the audio length, so the total is known once the job completes (POST /videos/price returns the exact amount beforehand). Image references are free. Editing (seconds: "-1") is charged at the 720p rate × the source length plus the input clip in tokens. Current prices — the catalog.

Strengths and limitations

A continuous 4–30 second duration — long shots and whole scenes with one model.
Six frame formats, including the wide 21:9, in three resolutions up to 1080p.
Three kinds of references in one request: up to 30 images, a clip and audio.
The first → last frame transition is supported (dashboard and bot).
A reproducibility seed for repeatable takes; native sound in the finished clip.
One video and one audio reference in the API; lists (up to 10 of each) — dashboard and bot only.
Editing an existing clip (seconds: "-1"): the output inherits the source’s duration and aspect ratio, rendered at 720p.

All models — in the catalog. The general video workflow — the video guide.