Seedance 2.0

Seedance 2.0 (bytedance/seedance-2.0) is ByteDance’s video model: strong character consistency, frame transitions, native sound, seven frame formats up to 4K. The family has three tiers: Standard — the main one, Fast (bytedance/seedance-2.0-fast) — cheaper and quicker for drafts, Mini (bytedance/seedance-2.0-mini) — budget short clips with a duration slider. 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.0` (the short `seedance-2.0`; the alias `seedance`), `bytedance/seedance-2.0-fast` or `bytedance/seedance-2.0-mini`
`prompt`	Scene description, required; up to 30 000 characters
`seconds`	Standard/Fast: one of 5, 10, 15 (defaults to 5). Mini: any integer from 4 to 15
`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 9 images in an array, also `data:` URLs only
`input_video`	Video reference: `{"video_url": "https://..."}` or a `data:` URL — motion is carried over to the character in your images. One clip in the API (up to 3 in the dashboard and bot)
`input_audio`	Audio reference: `{"audio_url": "https://..."}` or a `data:` URL — the soundtrack follows the track’s rhythm and mood. One track in the API (up to 3 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

Seven aspect ratios; the tiers differ in resolutions — Standard has four (up to 4K), Fast and Mini two:

Aspect	480p (all tiers)	720p (all tiers)	1080p (Std)	4K (Std)
`16:9`	`852x480`	`1280x720`	`1920x1080`	`3840x2160`
`9:16`	`480x852`	`720x1280`	`1080x1920`	`2160x3840`
`1:1`	`480x480`	`720x720`	`1080x1080`	`2160x2160`
`4:3`	`640x480`	`960x720`	`1440x1080`	`2880x2160`
`3:4`	`480x640`	`720x960`	`1080x1440`	`2160x2880`
`21:9`	`1120x480`	`1680x720`	`2520x1080`	`5040x2160`
`9:21`	`480x1120`	`720x1680`	`1080x2520`	`2160x5040`

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 9 references, no extra charge.
Clip (input_video): mp4 or mov, 2 to 30 seconds (longer is trimmed), a frame of at least 407 696 pixels, a link up to 50 MB or data: up to 40 MB. Combines with input_references; not with input_reference.
Audio (input_audio): mp3, wav, m4a, aac, ogg, opus or flac; 1 to 30 seconds, up to 20 MB.
Links must be https on a public host; redirects are not followed; the file is checked before the job is created.
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; via /v1 only the starting frame is accepted.

Examples

import requests

job = requests.post(
    "https://api.mixen.ai/v1/videos",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "model": "bytedance/seedance-2.0",
        "prompt": "A girl walks through an evening market, garland lights reflect in shop windows, the camera follows",
        "seconds": "10",
        "size": "1280x720",
    },
).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.0",
    "prompt": "A girl walks through an evening market, garland lights reflect in shop windows, the camera follows",
    "seconds": "10",
    "size": "1280x720"
  }'

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

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("scene.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.0",
        "prompt": "The camera slowly pulls back, the hero surveys the panorama, steady motion",
        "seconds": "5",
        "size": "1280x720",
        "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")

IMG=$(base64 -w0 scene.jpg)
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.0\",
    \"prompt\": \"The camera slowly pulls back, the hero surveys the panorama, steady motion\",
    \"seconds\": \"5\",
    \"size\": \"1280x720\",
    \"input_reference\": {\"image_url\": \"data:image/jpeg;base64,$IMG\"}
  }" | python3 -c 'import json,sys; print(json.load(sys.stdin)["id"])')

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 nine images — the model assembles the scene while keeping the characters and style of the references. For a rough draft of the same scene, bytedance/seedance-2.0-fast is cheaper:

{
  "model": "bytedance/seedance-2.0-fast",
  "prompt": "The character from @image1 gets into the car from @image2, a night yard",
  "seconds": "5",
  "size": "1280x720",
  "input_references": [
    "data:image/png;base64,iVBORw0...",
    "data:image/png;base64,iVBORw0..."
  ]
}

Images + clip + audio in one request

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

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. Standard: 480p — 10.24 ₽ per second, 720p — 22.02 ₽, 1080p — 54.49 ₽, 4K — 113.23 ₽. Fast: 480p — 8.19 ₽, 720p — 17.61 ₽ (480p/720p only). Mini: 480p — 5.12 ₽, 720p — 11.01 ₽. Video and audio references are billed on top of the output seconds — the total is known once the job completes (POST /videos/price returns the exact amount beforehand); image references are free. Current prices — the catalog.

Strengths and limitations

Strong character consistency: the same hero holds across frames and references.
Seven frame formats — from square to the ultra-wide 21:9 and 9:21; Standard up to 4K.
Three kinds of references in one request: up to 9 images, a clip and audio.
The first → last frame transition — in the dashboard and bot; via /v1 only the starting frame.
Native sound; a reproducibility seed.
Fixed 5/10/15-second durations (Mini — a 4–15 slider); no continuous range or 30-second plans like Seedance 2.5.

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