Seedance 2 Fast API: 50% Off on Segmind, the Best Seedance Cost for Developers

The Seedance 2 Fast API is $2.80 per million tokens on Segmind, exactly half of BytePlus's rate. Exact billing math, measured costs, four real clips.

Seedance 2 Fast API on Segmind at 50% off, pricing and cost breakdown

Seedance 2.0 Fast is now $2.80 per million tokens on Segmind. BytePlus, who make the model, list it at $5.60. That is exactly half, on both of the model's rate tiers, and it holds at every duration and resolution the model supports.

I do not like publishing a discount claim without the arithmetic behind it, so this post is the arithmetic. I solved the billing formula against real generations, checked every rate against BytePlus and fal, and fired four clips on the Segmind endpoint to confirm that what the API charges matches what the formula predicts. It does, to the seventh decimal place. Along the way I found two things worth knowing before you build on this model: the extra frame you are billed for is a real frame, and a cheap 480p draft will not give you the same shot at 720p.

What Seedance 2.0 Fast actually is

Seedance 2.0 Fast is ByteDance's cost-reduced tier of Seedance 2.0. Segmind's own model page describes it as similar to Seedance 2.0 but faster and cheaper, and the published average latency backs the "faster" half: 152.43 seconds against 232.34 for Seedance 2.0. It generates video with native synchronised audio from a text prompt, a first frame, up to nine reference images, up to three reference videos, or up to three reference audio files.

The trade is resolution. Seedance 2.0 reaches 1080p and 4k. Fast stops at 720p, with 480p below it, and that is the whole ceiling. If you need a 4k master, Fast cannot give you one at any price and you are back on Seedance 2.0.

Everything else is the same. I diffed the input schemas for Seedance 2.0 Mini, 2.0 Fast and 2.0: all three expose an identical set of fifteen parameters, with the same names, types and enums. Moving between tiers is a one-line change to the slug in your endpoint URL. No request rewriting, no new fields to learn.

What the 50% actually refers to

Seedance bills on tokens, not on seconds or per clip, and there are two rate tiers depending on what you feed it. Here is Segmind against BytePlus ModelArk, the model's first-party platform:

Input type Tokens billed BytePlus official Segmind Cut
Text or imageOutput video only$5.60 /M$2.80 /M50.0%
VideoReference video + output$3.30 /M$1.65 /M50.0%

Both tiers land at exactly half the first-party rate.

Note which tier your job lands in. The video-input rate looks cheaper per token, but it bills your reference video on top of the output, so the effective cost per second of delivered video is usually a little higher than the text or image path. A lower rate on a bigger token count is not a saving.

The billing formula, solved

You do not have to guess what a clip will cost. Seedance prices output as a pixel count, and I solved it exactly:

frames = 24 × duration + 1
tokens = floor(width × height × frames / 1024)
cost   = tokens × rate / 1,000,000

At 720p the canvas is 1280x720, which is 900 tokens per frame. At 480p in 16:9 it is 864x496, or 418.5 tokens per frame. I confirmed both with ffprobe on the returned files rather than assuming them.

Two fires, prediction against what the API actually charged on the x-cost response header:

Config Tokens Formula predicts Actually billed
720p, 5s, 16:9108,900$0.304920$0.304920
480p, 5s, 16:950,638$0.1417864$0.1417864

Exact. Note the floor: 480p computes to 50,638.5 tokens and bills 50,638.

That +1 in the frame count is the part people misread as a rounding surcharge. It is not. I counted the frames in the returned 5-second file and got exactly 121, which is 24 times 5 plus 1. The clip is 5.04 seconds long. You are billed for one extra frame because the model delivers one extra frame. Nothing is being padded.

The practical effect is that per-second cost is stable and you can quote a job before you run it. At 720p that is $0.06048 per second, at 480p $0.028123 per second. Both reproduce the per-second table on the Segmind pricing page to four decimals, which is a useful cross-check that the rate card and the billing engine agree.

Duration 480p 720p
4s$0.1137$0.2444
5s$0.1418$0.3049
6s$0.1699$0.3654
8s$0.2262$0.4864
10s$0.2824$0.6073
12s$0.3387$0.7283
15s$0.4230$0.9097

Every supported duration in 16:9, computed from the formula. Audio is included at no extra cost.

Against the other places you can run it

fal publishes the same token formula and charges $0.2419 per second at 720p, which works out to $11.20 per million tokens. One caution on comparisons: fal's formula has no +1 frame, so I computed their column with their own frame count rather than ours. Using our token count against their rate would overstate them slightly, and I would rather the table be conservative.

720p clip Segmind BytePlus fal
5 seconds$0.3049$0.6048$1.2096
10 seconds$0.6073$1.2096$2.4192
15 seconds$0.9097$1.8144$3.6288
100 clips/day, 5s, per month$914.76$1,814.40$3,628.80

A 100-clip-a-day pipeline saves $2,714.04 a month against fal and $899.64 against BytePlus.

Which Seedance tier should you actually use

Here is the part a pricing post usually skips. Fast is not the cheapest Seedance on Segmind. Seedance 2.0 Mini is, at $1.75 per million tokens, and it also caps at 720p with the same duration options and the same fifteen parameters.

Tier Rate 720p 5s Max res Avg latency
2.0 Mini$1.75 /M$0.1906720p154.35s
2.0 Fast$2.80 /M$0.3049720p152.43s
2.0$7.00 /M$0.76234k232.34s
2.5$10.97 /M$1.19461080p340.25s

Latency figures are the published averages on each model's Segmind page.

So the honest positioning: Fast is the cheapest way to get Seedance 2.0 class output, and Mini is 37.5% cheaper again because it is a smaller model rather than a discounted 2.0. Fast being the quickest of the four is a genuine surprise, and it makes Fast the sensible default for anything iterative.

I wanted to know what that 60% premium over Mini actually buys, so I ran the earbud prompt again on Mini with the same seed and the same parameters, changing nothing but the slug.

Seedance 2.0 Mini, same prompt and seed, 720p, 5s, billed $0.190575. Compare against the Fast version above.

Mini held the brief. Hand-only framing, the lid lifting on cue, two earbuds in the cradle, the amber LED lit, no invented branding. On this prompt I could not justify the premium from the output alone, and I am not going to pretend otherwise to make the more expensive tier look better. What one clip cannot settle is consistency: the tier gap on Seedance shows up on harder prompts, longer durations and busier scenes, not on a tightly specified five-second product beat where the model has little room to go wrong.

The practical read: prototype on Mini, and move a workload up to Fast when you can measure Mini failing on your actual prompts. Reach for 2.0 when you need above 720p and 2.5 when you need longer than 15 seconds. Because the parameter surface is identical, that migration costs you one string.

A D2C product demo, start to finish

This is the job Fast is built for: a clean product beat that would otherwise be a studio half-day.

Prompt used Macro product demo, commercial quality, shot on a cinema camera with a 100mm macro lens. A matte black wireless earbud charging case rests on brushed concrete, soft diffused daylight raking in from the left. Hands only, no face in frame: fingers enter and lift the hinged lid, revealing two earbuds seated in their cradle with a single amber status LED pulsing slowly. Shallow depth of field, gentle slow push-in toward the open case. The product is completely unbranded: no text, no logos, no lettering anywhere in the frame. Audio: quiet indoor room tone, a soft magnetic click as the lid releases, faint fabric rustle from the hand. No music.

Parameters duration: 5  |  resolution: 720p  |  aspect_ratio: 16:9  |  generate_audio: true  |  bitrate_mode: high  |  seed: 770145  |  billed: $0.304920

Seedance 2.0 Fast output, 720p, 5s, $0.304920. Rendered in 128.5 seconds.

It held every constraint I cared about: hands only with no face drifting into frame, the lid opening on cue, the amber LED present and pulsing, the push-in slow rather than a lurch, and no invented brand marks or lettering on the product. That last one matters more than it sounds. Vague product prompts invite these models to invent a logo and a tagline, and then you have a clip you cannot ship. Closing the label set explicitly in the prompt is the fix.

It did reinterpret the set. I asked for brushed concrete and daylight from the left and got a darker surface with window blinds behind. Prompt adherence on subject, action and camera was strong. Adherence on environment was looser.

Drafting at 480p, and the trap in it

480p costs 53.5% less than 720p for the same duration, so the obvious workflow is to iterate at 480p and re-render the winner at 720p. I tested that directly: same prompt, same seed, only resolution changed.

Identical prompt and seed 770145 at 480p, billed $0.1417864. A different take, not a smaller version of the same one.

It is a completely different shot. Different case geometry, a pale concrete surface instead of a dark one, light streaking in from the left instead of blinds behind, and a higher camera. The seed does not survive a resolution change on this model.

So use 480p to validate prompt wording, timing and whether the action reads at all. Do not use it to lock composition, because the composition you approve is not the one you will get. If you need to pin a look before spending at 720p, pin it with first_frame_url instead of with the seed. That does carry across, and image inputs are free.

Multi-shot in a single call

Fast inherits the Shot 1: / Shot 2: prompt syntax, so a cut happens inside one generation and one bill rather than two calls plus an edit.

Prompt used Shot 1 [00:00-00:05]: Overhead macro shot, a gooseneck kettle pours a slow spiral of hot water over fresh coffee grounds in a white ceramic pour-over cone. The bed of grounds blooms and crackles, steam curling upward through hard morning sunlight coming from a window on the left. Hands only, no face in frame. Shallow depth of field, slow clockwise camera drift.
Shot 2 [00:05-00:10]: Cut to a low side angle at table height. The finished cup of black coffee sits on pale oak, steam rising steadily. A hand sets a small ceramic spoon down beside the cup and withdraws from frame. Warm rim light, soft falloff into shadow. Slow push-in.
All ceramics and the kettle are plain and unbranded: no text, no logos, no lettering anywhere in the frame. Audio: quiet kitchen room tone, the sound of pouring water, a faint crackle from the coffee bloom, one soft ceramic clink. No music.

Parameters duration: 10  |  resolution: 720p  |  aspect_ratio: 16:9  |  generate_audio: true  |  bitrate_mode: high  |  seed: 418902  |  billed: $0.607320

Seedance 2.0 Fast output, 720p, 10s, two shots in one call, $0.607320. Rendered in 136.7 seconds.

One generation, one cut, one bill of $0.607320. Scene detection on the returned file finds exactly one transition, at 5.58 seconds rather than the 5.0 I asked for, so it ran the first shot slightly long and split the clip 5.6 to 4.5. Both shots matched their descriptions closely: the overhead pour with the bloom crackling in shot one, the low table-height angle with the spoon being set down in shot two. If you need frame-accurate cuts, cut it yourself in post. If you need a two-beat sequence that reads properly and costs one call, this works.

One prompting note that carries over from the rest of the Seedance family: be specific about audio and say "no music". Asking for music tends to trip the copyright check, and the failure arrives after the render rather than before it. Describing room tone and specific effects gets you a usable bed instead. Audio costs nothing either way, so there is no reason to turn it off except to save yourself a listen.

Wiring it up

The endpoint is synchronous and returns the MP4 as binary in the response body. There is no job ID and nothing to poll.

import requests

r = requests.post(
    "https://api.segmind.com/v1/seedance-2.0-fast",
    headers={"x-api-key": API_KEY},
    json={
        "prompt": "...",
        "duration": 5,
        "resolution": "720p",
        "aspect_ratio": "16:9",
        "generate_audio": True,
        "bitrate_mode": "high",
    },
    timeout=600,
)
# what it actually charged, not an estimate
print(r.headers["x-cost"])
open("out.mp4", "wb").write(r.content)

Four things I would build in from the start. Set your client timeout above 600 seconds, because latency is not a function of duration and the spread is wide. Read x-cost on every response and log it, since that is the only per-call record of what you spent. Treat failures as free, because they bill nothing, which makes parameter iteration cheap. And remember generate_audio defaults to true here, so you get audio whether you planned for it or not.

Output shape is web-ready without a transcode: H.264 High profile, 8-bit yuv420p, 24fps, stereo AAC at 32 kHz. On bitrate_mode: high my 720p clip came back at 9.9 Mbps against roughly 5.2 at 480p, and the high setting costs nothing extra. Worth knowing that higher Seedance tiers do not all behave this way: 1080p on 2.5 returns 10-bit HEVC that browsers refuse to play inline.

Honest assessment

The ceiling is real. 720p is fine for social, product pages and ads, and it is not fine for broadcast delivery or anything that will be scaled up. If you need 1080p or 4k, this tier is the wrong tool and no amount of savings changes that.

Latency is unpredictable in a way the average hides. The published figure is 152 seconds, my two 5-second clips took 128.5 and 92.4 seconds, and across the wider Seedance family I have seen single generations run past ten minutes. Budget by cost, which is deterministic, and never by wall clock.

Real human faces are blocked across every Seedance tier, so casting-led work is out. Moderation can also fire after the render completes rather than before, which costs you the wait even when it costs you nothing in credits. And the 480p seed behaviour above is the kind of thing that quietly wastes a day if you assume it works like an image model.

FAQ

How much does the Seedance 2 Fast API cost on Segmind?

$2.80 per million output tokens for text or image input, and $1.65 per million when you pass a reference video. A 5-second 720p clip is $0.3049 and a 15-second one is $0.9097.

Is the Seedance 2 Fast API really 50% off?

Yes, measured against BytePlus ModelArk's first-party rates of $5.60 and $3.30 per million tokens. Segmind sits at exactly half on both tiers. It is the lowest published rate for this model I could find.

How do I calculate a Seedance 2.0 Fast bill before running it?

Take floor(width x height x (24 x duration + 1) / 1024) for your token count, then multiply by the rate over one million. Use 1280x720 for 720p and 864x496 for 480p in 16:9.

Is Seedance 2.0 Fast cheaper than Seedance 2.0 Mini?

No. Mini is $1.75 per million tokens, about 37.5% below Fast. Fast is the cheapest tier that gives you Seedance 2.0 class output, but Mini is the cheapest Seedance overall.

What resolutions and durations does Seedance 2.0 Fast support?

480p and 720p only, in 16:9, 9:16, 1:1, 4:3, 3:4, 21:9 or adaptive. Durations run from 4 to 15 seconds. For 1080p or 4k you need Seedance 2.0.

Does audio cost extra on the Seedance 2 Fast API?

No. Native audio generation is free and generate_audio defaults to true. Billing tracks output pixels and duration only, which my measured costs confirm to seven decimal places.

Worth building on

Seedance 2.0 Fast at $2.80 per million tokens is the tier I would reach for by default: near enough to Seedance 2.0 in quality, the fastest of the four tiers, and half the price of running it at the source. The billing is fully predictable, which matters more than the headline discount when you are costing a pipeline rather than a demo. Just size it honestly. 720p is the ceiling, Mini is cheaper if your use case tolerates it, and a 480p draft tells you about your words and not about your frame.

Run Seedance 2.0 Fast on Segmind, or compare it against Seedance 2.0 Mini and Seedance 2.0 before you commit a workload.