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 duration bills 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:

Groupp50 (s)p90 (s)
All Fast clips163214
720p clips167211
4 to 5 second clips149213
Image-to-video (first frame)169212

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 failCode and a retryable flag. Retry UPSTREAM_BUSY, UPSTREAM_FAILED and TIMEOUT once or twice, with a pause between attempts. Do not retry CONTENT_MODERATION, INVALID_INPUT or INSUFFICIENT_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 id480p720p1080p
seedance-2.0-mini0.0440.095not offered
seedance-2.0-fast0.0710.153not offered
seedance-2.00.0920.1970.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.

评论

此博客中的热门博文

GPT Image 2 API: Which Model ID to Use, from $0.01 per Image

Wan 3.0 Video API: 30-Second Clips from $0.045 per Second