Turning per-second rates into the cost of a finished minute

Updated 2026-10-02

Video APIs quote a price per second, but what you actually buy is a finished minute: a sequence of clips, some of which you throw away. The arithmetic is simple, and the mistakes come from the factors people leave out. This page gives a formula you can paste into a spreadsheet, shows where each factor comes from, and points to the live tools on this site that supply the rates.

The baseline: one minute of generated seconds

If every generated second ends up in the final cut, the cost of a minute is 60 * P * (1 + F), where P is the per-second rate for your model, host and resolution tier, and F is the platform fee. VideoRouter adds a flat 2% on image and video, so F is 0.02. Charges are made once at job creation from the requested duration, polling is free, and a job that fails upstream is not billed.

The table below shows the live cost of 5-second, 10-second and 60-second outputs at the cheapest host for each model. The 60-second column is the baseline minute under the assumption that every generated second is used and each clip bills only what you requested:

Computed from each model's cheapest current host per resolution tier, before VideoRouter's 2% platform fee. Built 2026-10-02 from live data. Failed upstream jobs are not billed; re-generations are, so multiply by your retry rate.

Rates are for the tier named in each row, and they are rebuilt from the live catalog. For your own model, tier and clip length, use the calculator, and see the cost tables for the static version of the same numbers.

Why a finished minute costs more than the baseline

Four factors multiply the baseline. Write them down per project:

cost_per_finished_minute = 60 * E * Q * R * (1 + F) * sum(M_i * P_i)

# M_i: share of generated seconds at tier i, P_i: that tier's per-second rate
# Without drafts: M is 1 and the sum is just P.

The tier mix matters more than it looks. If drafting costs a lot of attempts at a low tier before one final at the delivery tier, the draft stage is part of the cost of the minute, not an overhead. Count it as its own term in the sum.

Clip count: the minute is not one request

Each model has a maximum clip duration, which you should read from its model page. A finished minute built from clips of length L needs ceil(60 / L) successful clips at minimum, and usually more because of trims and retakes. Duration snapping is the quiet one: if you ask for a length the model does not offer, it is moved to the nearest value that it does, and you are billed on that value. Read the billed seconds from the response, not from your request.

import math

def finished_minute_cost(rate_per_sec, clip_secs, *, fee=0.02, retry=1.0,
                         edit_ratio=1.0, snap=1.0):
    clips = math.ceil(60 / clip_secs)               # minimum clips for the footage
    billed_secs = clips * clip_secs * snap          # what the API actually bills per pass
    generated = billed_secs * edit_ratio * retry
    return generated * rate_per_sec * (1 + fee)

# rate_per_sec comes from the live table or the calculator, never a constant in code

Note that edit_ratio and retry both multiply the number of generated seconds, but they come from different places: one is a creative choice, the other is a quality outcome. Track them separately, because you can reduce them differently. Better prompts lower R; tighter shot planning lowers E.

Not everything is per-second

Some models charge a flat amount per clip or per request regardless of duration, and some add components for reference inputs. The unit is stated on each model's page. For flat-priced models the finished-minute cost is the clip count times the per-clip price times R and (1 + F), and a longer clip is the cheaper way to cover the same seconds. Check the unit before you apply the per-second formula to any model you have not priced before.

A symbolic example, end to end

1. Pick the model and tier. Read P and the maximum clip length from the live table.
2. Set L to the clip length you will request. Compute ceil(60 / L) clips.
3. Estimate R from a pilot of 30 to 50 prompts: total generations divided by accepted clips.
4. Estimate E from a rough cut: generated seconds divided by seconds kept.
5. Plug them in. Then vary R and E by plus and minus 30% and look at the spread. If the budget breaks at the pessimistic end, you have a process problem, not a rate problem.

For monthly budgeting across many projects, use the volume formula in the budget guide. To see how the rate itself shifts with tier, read the resolution guide, and for host selection the cheapest-API guide. The price index shows each model's cheapest and priciest host. Create a key at videorouter.sh/signup when you are ready to run the pilot.

Frequently asked questions

Keep reading

• How AI Video API Pricing Works — Per-Second, Per-Tier, Per-Host
• Cheapest Video Generation API: How to Find It for Your Workload
• Video API Pricing by Resolution: 480p to 4K Per-Second Costs
• How to Estimate Your AI Video API Budget, Step by Step