
Per-second vs per-clip pricing for AI video APIs: how to budget a video workload
Video models are billed by the second, by the clip or by credits. Here is how to turn each pricing unit into a real budget, with worked numbers for Seedance 2.0 and Wan 2.7 on one OpenAI-compatible API.
Text models trained everyone to think in tokens. Video breaks that habit. A video call is priced by how many seconds of footage come back, sometimes by the clip, and in many browser tools by a credit balance that hides the dollar figure. If you budget a video feature with text-model instincts, you will be wrong by a wide margin.
This post explains what each pricing unit really means, puts numbers on the two video models Cheap Model currently routes, and gives you a formula for the figure that matters: what one usable second of footage costs you.
Three pricing units you will run into
Per second of output. You pay for the length of the clip you asked for. A 10-second request costs twice a 5-second request, whatever the prompt. This is how most video APIs price, including the video routes on Cheap Model.
Per clip at a fixed length tier. Some models only render specific lengths, such as 4, 6 or 8 seconds. You pay for the tier, not the seconds you end up using.
Credits. Browser tools usually sell credit packs or monthly credit allowances, and each model and length costs a set number of credits. Some still publish the rate per second. Dolai's model catalog, for example, lists every video model it runs with a price in credits per second: 13–20 credits per second for H3 Max Turbo, 25–40 for H3 Max and 48–266 for Seedance 2.5, depending on resolution. Credits are still a per-second price. You just have to convert them back into dollars before you can compare.
What video costs on Cheap Model today
Cheap Model routes two video models, and both are called through the same key and the same async task flow as everything else: you submit to /v1/videos/generations, get a task ID back, then poll /v1/tasks/{task_id}. The API compatibility guide covers the request shape.
| Model ID | Output listed | Cheap Model price | Listed official price | 5s clip | 10s clip | 15s clip |
|---|---|---|---|---|---|---|
seedance-2.0 | 2K video, up to 15s | $0.098 / second | $0.140 / second | $0.49 | $0.98 | $1.47 |
wan2.7 | 720P/1080P, 2–15s | $0.070 / second | $0.100 / second | $0.35 | $0.70 | $1.05 |
The clip columns are simple multiplication, and that is the point. With per-second pricing the request itself tells you the cost before you send it: model rate times requested duration. Nothing depends on prompt length or how busy the scene is.
Both models are pinned to a single upstream. seedance-2.0 goes to EvoLink and wan2.7 goes to APIMart, and Cheap Model does not silently retry the call on another provider. For budgeting, that means one request is billed at one known rate. The reasoning is in routing and provider policy.
Length tiers: you pay for the take, not the cut
Per-second pricing only stays simple when you can ask for the exact length you need. Many models offer a fixed menu instead. Veo 3.1 is a good example: a browser studio built around Veo 3.1 offers it in 4, 6 or 8-second takes, priced per clip (100 credits for 4 seconds of Veo 3.1 Lite, 200 for 8 seconds, 600 for 8 seconds of Veo 3.1 Fast).
That changes the planning. If your edit needs a 3-second insert, you still buy a 4-second take. If a shot needs 9 seconds, you buy two clips and cut them together. On a range-based model like wan2.7 (2–15 seconds) you can request close to the length you will actually use, so less footage ends up trimmed and thrown away.
Rule of thumb: for short inserts and cutaways, models that accept small, flexible durations waste the least money. For long continuous shots, compare the price of one long take against two shorter ones, because longer takes also fail in more interesting ways.
The number that matters: cost per usable second
The price list tells you what a generation costs. Your budget depends on how many generations you throw away. Video models still miss: a hand goes wrong, the camera move ignores the prompt, a product label melts. So the honest formula is:
cost per usable second = price per second × attempts per keeper
A worked example: a 60-second product video built from six 10-second shots, where you expect about three attempts per shot before one is good enough.
- On
wan2.7: 6 shots × 10 s × 3 attempts × $0.070 = $12.60 - On
seedance-2.0: 6 shots × 10 s × 3 attempts × $0.098 = $17.64
Two things follow from this.
- Draft short, finish long. Explore prompts with 4–5 second requests. Once a prompt works, render the full-length take. Six exploration attempts at 5 seconds cost the same as three at 10 seconds.
- Your attempt rate is a cost lever. Halving attempts per keeper halves the budget, regardless of model. Better prompts, a reference image and one main action per shot are usually worth more than switching to a cheaper model.
API pricing vs credit-based tools
Teams often prototype in a browser tool, then move to an API for production. The two price their work differently, so compare them carefully.
Credit tools sometimes publish tables per clip instead of per second. ToonBee does this for MiniMax H3: a 5-second clip is 63, 100 or 200 credits on H3 Max Turbo at 480p, 768p or 1080p, and 125, 200 or 400 on H3 Max. To compare that with a per-second API, you need the dollar value of a credit, and that depends on how you buy them. On that site, plans start at $39 a month for 5,000 credits, about $0.0078 per credit, while the $9.90 pack for 600 credits works out to about $0.0165. The same 100-credit clip is roughly $0.78 on the plan and $1.65 from the small pack.
| Per-second API (e.g. Cheap Model) | Credits priced per second | Credits priced per clip or tier | |
|---|---|---|---|
| How you predict cost | Rate × requested seconds | Credits per second × seconds, then credits → dollars | Table lookup, then credits → dollars |
| Dollar cost depends on | Model and duration | Plan or pack you bought | Plan or pack you bought |
| Best for | Products, batch jobs, automation | Hands-on creation with flexible lengths | Quick creative work with fixed lengths |
| Integration | Code, async tasks, one key | Web interface | Web interface |
| Watch out for | Retries you trigger from code | Unused monthly credits | Paying for seconds you trim |
Neither model is better in general. The API wins once video generation sits inside your product or a scheduled pipeline, because the cost is a line of arithmetic your code can enforce. Credit tools win for creative exploration, when you want a preview, a gallery and a download button more than an endpoint.
A short budgeting checklist
- Write down the price unit for every model you use: per second, per tier, or credits. Convert all of them to dollars per second.
- Estimate attempts per keeper from a small test batch, not from hope. Ten prompts are enough to see the pattern.
- Cap duration in code. A user-facing feature that lets people request 15 seconds when 5 would do triples your exposure.
- Keep exploration and final renders on separate budgets, and consider separate models.
- Check current rates on the pricing page before you commit a number to a plan, since per-second rates change as models and upstreams change.
Video is the most expensive modality most teams will add, but it is not hard to predict. Once every model's price is a dollar figure per second and you know your attempt rate, the budget is just multiplication.
More Posts

Building one API surface for text, image, video, and audio workloads
Why Cheap Model treats multimodal access as a platform problem instead of a collection of disconnected endpoints.

Using routing and fallback to control AI spend before it controls you
A practical look at cost control when teams mix premium and lower-cost model routes.

Why Cheap Model starts with one compatible integration layer
Compatibility lowers migration cost, but it also creates a cleaner foundation for routing, pricing, and provider choice.
Newsletter
Join the community
Subscribe to our newsletter for the latest news and updates