Seedance 2.0 Fast API: 480p and 720p Video from $0.071 per Second
If you are putting Seedance 2.0 Fast into a product, here is the short version. It is the 480p and 720p tier of ByteDance's Seedance 2.0 and takes the same inputs as the full model. A finished clip takes close to three minutes, so build around a task id and a webhook, not a blocking call. Billing is per second of output, from $0.071 at 480p and $0.153 at 720p. The rest of this post puts numbers behind each point.
Disclosure up front: the measurements below come from apimodels.app, which is the API I work on. apimodels.app is a multi-model API gateway: one API key and one OpenAI-compatible endpoint for image, video, audio and language models. Latency, failure and output figures come from our production traffic over the last 7 days (sample size not disclosed), rounded to whole seconds and whole percent.
Fast, standard or Mini
All three Seedance 2.0 tiers take the same request body, so moving a job from one to another means changing one string.
- seedance-2.0-fast renders 480p or 720p clips of 4 to 15 seconds. It accepts a text prompt, a first frame or a first and last frame, up to 9 reference images, 3 reference videos and 3 reference audio clips, plus optional web search, and generates a synced soundtrack by default. It suits product clips, social video and volume work.
- seedance-2.0 is the full model and the only tier with 1080p. Use it for the final render.
- seedance-2.0-mini keeps the same inputs at 480p and 720p and is the lowest-priced tier, a natural fit for storyboards and drafts.
Fast has no 1080p: ask for it and you get a 400 at creation, not a quiet 720p render. Our docs page still shows the older alias seedance-2.0-fast-official in its examples; both names reach the same model.
What a request looks like
Video generation is asynchronous: the POST returns a task id that you poll, or you receive a webhook. Example below (written against our docs, not run here; swap in your own key and image URL):
import os, time, requests
BASE = "https://api.apimodels.app/v1"
H = {"Authorization": f"Bearer {os.environ['APIMODELS_API_KEY']}"}
r = requests.post(f"{BASE}/video/generations", headers=H, timeout=30, json={
"model": "seedance-2.0-fast",
"prompt": "The ceramic mug turns slowly on a wooden table, steam rising, "
"soft morning light, the camera pushes in",
"first_frame_url": "https://example.com/mug.jpg", # image-to-video
"resolution": "720p",
"aspect_ratio": "16:9",
"duration": 5, # leave it out and you are billed for 8 seconds
# "callback_url": "https://your.app/hooks/video", # better for batches
})
r.raise_for_status()
task_id = r.json()["data"]["taskId"] # save this before you start polling
while True:
time.sleep(15)
task = requests.get(f"{BASE}/video/generations", headers=H,
params={"task_id": task_id}, timeout=30).json()["data"]
if task["state"] in ("completed", "failed"):
break
if task["state"] == "failed":
print(task["failCode"], "retryable:", task["retryable"])
else:
print(task["resultUrls"][0])
rec = requests.get(f"{BASE}/records/{task_id}", headers=H, timeout=30).json()["data"]
print("charged (USD):", rec["credits"])
A few defaults matter before you run a batch:
- Leaving out
durationbills 8 seconds. The API fills in 8, so a 720p clip you meant to keep at 5 seconds costs $1.23 instead of $0.77. - Resolution defaults to 720p and aspect ratio to 16:9. The accepted ratios are 21:9, 16:9, 4:3, 1:1, 3:4, 9:16 and adaptive.
- Pick one input mode. A first or last frame cannot be combined with reference images, videos or audio; such a request is rejected at creation with a 400.
- Audio is generated unless you send
"generate_audio": false, and it does not change the price. - Output files are kept for 30 days, so copy them to your own storage.
How long it takes
End-to-end time from submit to finished video, successful Seedance 2.0 Fast tasks only, including queueing and any rerouting:
| Group | p50 (s) | p90 (s) |
|---|---|---|
| All Fast clips | 163 | 214 |
| 720p clips | 167 | 211 |
| 4 to 5 second clips | 149 | 213 |
| Image-to-video (first frame) | 169 | 212 |
The groups overlap; most of this week's traffic was 720p image-to-video. 480p, text-only and 8 to 15 second clips, and the standard and Mini tiers, did not have enough data this week to report on their own.
Two consequences:
- Do not hold a web request open for it. Three and a half minutes is longer than most load balancers and serverless functions will wait. Return your own job id and let
callback_url, or a poll every 10 to 20 seconds, finish the work. - Expect a tail. A few clips take far longer than p90, and the gateway allows a video task up to 60 minutes on a route before declaring a
TIMEOUT. A 5 or 10 minute client cutoff abandons clips that keep rendering, and a clip that completes is billed whether or not you are still listening.
How often it fails, and what to retry
Over the same 7 days, about 2% of accepted Fast tasks were refused by content moderation and about 2% were rejected by the model as invalid parameters. No task failed with a busy, rate-limit or timeout error.
Both moderation refusals were copyright flags raised on the finished video, so they arrived minutes after submission. Design your UI for a late "failed" state.
Every Seedance 2.0 tier has two upstream routes on the gateway. If the active route returns busy, a rate limit, an upstream failure or a timeout, the task moves to the other route with no action from the caller. No Fast task hit a route error this week.
Failed tasks cost nothing: the amount reserved at submission is released, and GET /v1/records/{task_id} reports credits: 0 for them.
On the client side:
- Every failed task carries a standard
failCodeand aretryableflag. RetryUPSTREAM_BUSY,UPSTREAM_FAILEDandTIMEOUTonce or twice, with a pause between attempts. Do not retryCONTENT_MODERATION,INVALID_INPUTorINSUFFICIENT_BALANCE; change the prompt, the parameters or the balance instead. - A network error on the POST is not a failed task. The task may already exist, so look under Records in the console before you resubmit; a blind retry renders, and bills, a second clip.
Did the clip match the request?
We read the actual files: every successful Fast clip this week came back at the requested resolution tier and length. Two details help with your own checks:
- 720p means 1280x720 at 16:9 and 720x1280 at 9:16, but 1112x834 at 4:3. 480p at 16:9 is 864x496, not 854x480.
- Each clip has one extra frame. A 5 second clip is 121 frames at 24 fps, about 5.04 seconds.
ffprobe -v error -select_streams v:0 -show_entries stream=width,height,nb_frames -of csv=p=0 clip.mp4 prints all three numbers. Run it before you store or publish a clip, whoever rendered it.
Prices, as of October 27, 2026
Per second of output, in US dollars:
| Model id | 480p | 720p | 1080p |
|---|---|---|---|
| seedance-2.0-mini | 0.044 | 0.095 | not offered |
| seedance-2.0-fast | 0.071 | 0.153 | not offered |
| seedance-2.0 | 0.092 | 0.197 | 0.492 |
The charge follows the usage the model reports, which scales with frames times pixels, so a clip settles slightly above seconds times rate because of the extra frame: a 5 second 16:9 Fast clip is $0.7703 at 720p and $0.3582 at 480p, against $0.765 and $0.355 from the table. 4:3 and 3:4 frames land about 0.6% higher again. With a reference video, its seconds are counted along with the output's at a lower per-second rate; check those tasks with GET /v1/records/{task_id}.
The same key also calls the other image, video, audio and language models, there is no separate ByteDance cloud account to open, the balance is pay-as-you-go, and failed tasks are not billed. Parameters are in the Seedance 2.0 API reference for the standard, Fast and Mini tiers.
A worked cost estimate
Say a shop is turning 300 product photos into short clips: one 5 second 480p draft per photo to review the motion, then 100 keepers rendered again as 8 second 720p clips, all on Fast:
Drafts 300 x 5 s x $0.071 (Fast 480p) = $106.50
Finals 100 x 8 s x $0.153 (Fast 720p) = $122.40
Estimate $228.90
Settled, with the extra frame per clip:
Drafts 300 x $0.3582 = $107.46
Finals 100 x $1.2287 = $122.87
Total $230.33
Drafting on Mini instead brings the draft line to 300 x $0.2227 = $66.81. Rendering the finals on standard Seedance 2.0 at 720p makes that line 100 x $1.5863 = $158.63. Refused or failed tasks add nothing to either total.
When not to use it
- You need 1080p. Fast stops at 720p. Use
seedance-2.0, the only Seedance 2.0 tier with 1080p, at $0.492 per second. - You need more than 15 seconds in one clip. Every Seedance 2.0 tier stops at 15 seconds; longer pieces must be stitched from several clips.
- You need video back in seconds. With a median close to three minutes, Fast belongs in background jobs, not behind a live preview.
- You need a direct contract with ByteDance, for example for enterprise compliance paperwork or committed spend. Go to ByteDance directly.
If none of those apply, the quickest test is one 4 second 480p Fast clip, which settles at $0.2871. Its task and exact charge then show up under Records in the apimodels.app console.
Drafted with AI assistance; prices and numbers checked against our API docs and records on Oct 25, 2026.
评论
发表评论