Seedance 2.5 Pricing: Tokens vs Per-Second API Costs

TL;DR: Seedance 2.5 does not have one universal cost per second. Its native meter is video tokens: output width × height × 24 fps × billable video seconds, divided by 1,024. LinkModel uses the same auditable token-based meter with a discounted unit rate. For a matched five-second 720p output, its $1.0982 estimate is about 27.2% lower than an Atlas estimate derived from its public 480p starting price and 52.5% lower than fal.ai. This guide shows the assumptions behind those comparisons.

Seedance 2.5 API pricing looks inconsistent because providers expose different layers of the same cost model. One page shows dollars per million tokens, another converts tokens into an approximate per-second number, and another publishes only a starting price. Those figures are not comparable until the resolution, frame size, frame rate, duration, and video-reference length match.

How does Seedance 2.5 calculate video tokens?

ByteDance estimates output-token consumption with this formula:

tokens = output_width
       × output_height
       × (input_video_duration + output_duration)
       × output_frame_rate
       ÷ 1024

Text, images, and audio do not add seconds to this formula. A video reference does, because every input-video second is combined with the generated output duration. The final bill should use the API response's usage.completion_tokens; the formula is for planning.

For a 1280×720 output at 24 fps:

tokens per second = 1280 × 720 × 24 ÷ 1024
                  = 21,600 tokens

A five-second output therefore consumes an estimated 108,000 tokens without video input. A 30-second output consumes 648,000 tokens. The relationship is linear only while width, height, frame rate, and billing rules stay unchanged.

The exact pixel dimensions matter more than the marketing label. Two endpoints can both say “480p” while returning different widths or padded heights, which changes the token count. Always calculate with the dimensions accepted by the endpoint rather than treating 480p or 720p as a complete specification.

What is the official Seedance 2.5 token price?

There are two official regional price books, and they should not be converted into one another with a live exchange rate.

Use the BytePlus row when comparing USD prices from international API providers. Use the Volcano Engine row when budgeting a mainland-China account. They are separate regional list prices, not exchange-rate versions of one global rate.

For native 480p and 720p output, the published per-million-token rate is the same. The resolution changes the token count—not the token unit price—so a same-aspect-ratio 720p frame has approximately 2.25× the pixel area and per-second token consumption of a 480p frame.

The official pricing table also shows a 1080p price band, while the previously published API tutorial documented only 480p and 720p. A price row is not proof that every regional endpoint and account can already generate that specification. Confirm the live schema before treating 1080p as production availability.

How much does a matched 720p Seedance 2.5 video cost?

The cleanest competitor comparison starts with one exact workload: 1280×720, 16:9, 24 fps, no video input, successful five-second output. The comparison below uses LinkModel as the decision point: how much more would the same planned output cost on Atlas Cloud or fal.ai?

For the matched workload, choosing LinkModel instead of fal.ai saves approximately $1.213 per generation. Across 100 successful outputs, that is about $121.30 saved. Against the resolution-derived Atlas estimate, the corresponding saving is approximately $40.93 per 100 outputs.

The fal model page also displays a headline estimate of about $0.4730 per second at 720p, which would be $2.365 for five seconds. Its own token formula produces $0.46224 per second for 1280×720 at 24 fps. That roughly 2%–3% difference is why a production estimator should preserve the dimensions and use the task's final billable units instead of relying only on a rounded headline rate.

The Atlas row is an estimate, not a published 720p quote. It treats the advertised $0.134/second floor as the native 480p price and scales it by the 2.25× pixel-area relationship between same-aspect-ratio 480p and 720p. Atlas does not publish the full mapping, so confirm the logged-in request price before using the estimate for an invoice or contract.

Why can video input lower the rate but raise the bill?

Both BytePlus and fal publish a lower token rate when the request contains video input. The discount applies to the token rate, but input-video duration also increases the number of tokens.

For BytePlus, compare the two formulas:

No video input:  output_duration × $10.70 / M tokens
Video input:    (input_duration + output_duration) × $6.40 / M tokens

The video-input path is cheaper only when the input video is shorter than approximately 67.2% of the output duration. At 1280×720 and 24 fps, a ten-second output illustrates the crossover:

The five-second reference lowers the estimate by about 10%. The ten-second reference raises it by about 20%, even though the token rate is lower. Official billing can also apply a minimum token amount to video-input requests, so short jobs should use the returned usage rather than assuming the formula is always the final charge.

fal applies nearly the same mechanism. Its published $21.40/M rate receives a 0.6 multiplier when any video reference is present, but both input and output seconds remain billable. “0.6× token rate” does not mean “40% off the final request.”

Why is fal.ai about twice the official token price?

For requests without video input, fal publishes $21.40/M tokens against BytePlus's $10.70/M international list price. The same normalized token workload is therefore exactly 2× the official list-price baseline before taxes, credits, contracts, or promotions.

With video input, fal's 0.6 multiplier produces an effective rate of $12.84/M, while BytePlus lists $6.40/M. That is also approximately 2×. This is a unit-price comparison, not a claim about fal's infrastructure costs or the value of its SDKs, queue tooling, model catalog, and support.

fal states that Model API customers pay for successful outputs, not queue time or HTTP 500+ server errors. Its FAQ adds an important exception: some client errors can still be billed if GPU work began before the invalid request was detected. Technical success also differs from creative acceptance—a completed but unusable video is normally still a successful output for billing purposes.

Is Atlas Cloud really $0.134 per second?

Atlas currently advertises its Seedance 2.5 text-to-video, image-to-video, and reference-to-video endpoints from $0.134 per second. That is useful for discovery, but “from” is not a complete cost contract.

One useful reconstruction of the storefront price is resolution-derived upstream cost × platform coefficient × displayed discount. Observed prices can imply an intermediate coefficient around 1.6×, but Atlas does not publish that coefficient, the pre-discount amount, or a complete resolution matrix. The numerical estimate below therefore starts from the public $0.134 floor rather than treating 1.6× as a contractual markup.

Because the official 480p and 720p outputs use the same token unit price, their per-second cost relationship follows frame area when the aspect ratio and frame rate stay fixed:

Estimated Atlas 720p rate = $0.134 × (720 ÷ 480)²
                           = $0.134 × 2.25
                           = ~$0.3015 per second

That produces an estimated $1.5075 for five seconds at 720p. LinkModel's discounted token rate produces an estimated $1.0982 for the same workload, approximately 27.2% lower. This reconstruction assumes $0.134 is the native 480p floor and excludes ESR upscaling, 60 fps output, promotions, and account-specific pricing; Atlas has not published it as an official 720p formula.

What hidden costs should a Seedance 2.5 budget include?

A useful cost model separates the visible unit price from the effective cost of a usable result.

1. Actual frame area. Use width × height, not only a resolution label or aspect ratio.
2. Input-video duration. A lower rate may still produce a higher total when the reference is long.
3. Minimum billable tokens. Official video-input jobs can have a floor that exceeds the simple estimate.
4. Enhancement options. Upscaling and 60 fps processing should not inherit a native 24 fps starting price without evidence.
5. Technical versus creative success. Moderation or server failure may be free, but a technically successful result that misses the brief can require another paid generation.
6. Regional price books. BytePlus USD and Volcano Engine CNY are different offers; do not choose whichever looks lower after currency conversion.
7. Promotions and account discounts. Record list price, temporary promotion, prepaid-credit bonus, and negotiated price separately.

For production planning, calculate both cost per successful API response and cost per accepted creative output:

API unit cost      = total billed spend ÷ successful API outputs
Accepted-unit cost = total billed spend ÷ outputs your workflow actually keeps

The second number captures prompt retries, continuity failures, unusable dialogue, and other results that succeeded technically but failed the product requirement.

How can I estimate Seedance 2.5 API cost in code?

This small TypeScript function reproduces the public token formula. It is an estimator, not an invoice calculator; use usage.completion_tokens or a provider's request quote for reconciliation.

type SeedanceEstimate = {
  width: number;
  height: number;
  outputSeconds: number;
  inputVideoSeconds?: number;
  fps?: number;
  usdPerMillionTokens: number;
};
 
export function estimateSeedanceCost({
  width,
  height,
  outputSeconds,
  inputVideoSeconds = 0,
  fps = 24,
  usdPerMillionTokens,
}: SeedanceEstimate) {
  const billableSeconds = inputVideoSeconds + outputSeconds;
  const estimatedTokens =
    (width * height * billableSeconds * fps) / 1024;
 
  return {
    estimatedTokens,
    estimatedCostUsd:
      (estimatedTokens * usdPerMillionTokens) / 1_000_000,
  };
}
 
// 5s, 1280×720, no video input, BytePlus international list rate
estimateSeedanceCost({
  width: 1280,
  height: 720,
  outputSeconds: 5,
  usdPerMillionTokens: 10.7,
});
// { estimatedTokens: 108000, estimatedCostUsd: 1.1556 }

For a fal video-reference request, pass the combined input and output durations and use the effective $12.84/M rate. For BytePlus video input, use $6.40/M and remember that the official minimum-token rule can make a short request cost more than this estimate.

Which Seedance 2.5 pricing model is easiest to budget?

Each presentation has a legitimate use, but it answers a different question:

• Token-native pricing is the most auditable when you know the exact output dimensions and input-video duration.
• Derived per-second pricing is convenient when the provider discloses the resolution, frame rate, and input assumptions behind it.
• A “from” price is useful for catalog discovery but should not become a production budget without a request-level quote.
• Discounted token pricing with a pre-request estimate keeps the meter auditable while making the expected spend visible before submission.

LinkModel bills Seedance 2.5 by video tokens and applies a discounted token unit rate. For a matched five-second selection, the current estimates are $0.4883 at 480p and $1.0982 at 720p on its Seedance 2.5 pricing page. At 720p, that is approximately 27.2% below the resolution-derived Atlas estimate and 52.5% below fal.ai. Check the live model page before each rollout because prices, schemas, and available modes can change.

For a broader platform decision, compare the operational trade-offs in LinkModel vs fal.ai and LinkModel vs Atlas Cloud. The Seedance 2.5 release guide covers model capabilities and platform-specific IDs without duplicating this pricing analysis.

Frequently asked questions

How much does Seedance 2.5 cost per second?
There is no universal price per second. At 1280×720 and 24 fps, the BytePlus $10.70/M token list price converts to about $0.23112 per output second without video input, while fal converts to about $0.46224; scaling Atlas's $0.134 480p starting price by pixel area gives an unverified 720p estimate of about $0.3015 per second.

How many tokens does one second of Seedance 2.5 use?
At 1280×720 and 24 fps, one second uses an estimated 21,600 tokens. Other frame dimensions or frame rates produce a different number, and a video-reference request also adds the input-video duration.

Does a video reference make Seedance 2.5 cheaper?
Not always. BytePlus and fal reduce the token rate when video input is present, but they also count input-video duration; under the BytePlus rates, the reference must be shorter than about 67.2% of the output duration for the simple estimate to be lower.

Is LinkModel cheaper than fal for Seedance 2.5?
For the matched five-second 720p workload, LinkModel costs $1.0982 versus $2.3112 from fal's published token formula. Choosing LinkModel saves approximately $1.213 per successful generation, or 52.5%.

Why do ByteDance, fal.ai, and Atlas show different prices?
They expose different commercial layers: BytePlus publishes the upstream token list price, fal publishes a higher token price plus derived seconds estimates, and Atlas shows a starting per-second price without a complete public resolution matrix. Normalize the exact workload before ranking them.

The bottom line

Seedance 2.5 pricing becomes predictable once every provider is reduced to frame area, billable seconds, frame rate, and a dated unit price. Token rates can be compared directly; rounded seconds estimates and “from” prices need their assumptions attached.

Use the formula for planning, the request quote for approval, and final usage for reconciliation. Then compare the same accepted output—not two differently configured model cards.

Primary sources checked August 14, 2026: BytePlus pricing, Volcano Engine pricing, fal Seedance 2.5, fal Model API pricing, Atlas Seedance 2.5, and Atlas model billing.