Engineering your Veo spend: drafts, caching, tier gates

Updated 2026-10-02

The existing variant comparison explains how Veo 3.1, Fast and Lite differ. This page is about what to build around them. Per-second price is only one input to your bill. The number of generations you run, how many you throw away, and whether you ever pay for the same shot twice usually matter more.

Know where the money goes

Video is billed once at job creation from the requested duration_secs, plus a 2% platform fee, and polling is free. Jobs that fail upstream are not billed. So the cost of a shot is the sum of every attempt that succeeded and was not used. Three levers follow:

1. Price per second (variant, resolution, host).
2. Seconds per attempt (clip length requested).
3. Attempts per accepted shot (your retry factor).

Tier choice moves lever 1. A good pipeline mostly works on levers 2 and 3.

Lever 1: price, per variant and per host

Do not assume the host that is cheapest for one variant is cheapest for the others. Check each variant separately in the live table:

Per second, before VideoRouter's 2% platform fee. For tiered models each row compares the resolution tier with the widest host-to-host gap. Built 2026-10-02 from the live catalog.

Leaving routing automatic sends each request to the cheapest healthy host and fails over if a submission is rejected. Pin a host only when you need consistent behaviour, since pinning gives up some of that price advantage. For image input or a specific resolution, confirm the host supports it first.

Lever 2: draft short and small

Because you pay for requested seconds, a draft does not need the full runtime. Prototype motion with the shortest clip that shows it, at the lowest resolution you can judge, on the cheapest variant. Only the final render should carry the full length and delivery resolution. Be aware that some hosts ignore the resolution and aspect_ratio fields, so verify what you actually received before you decide a draft was "cheap".

Lever 3: a promotion ladder with a budget per stage

Treat the three variants as stages with explicit exit criteria:

A cheaper stage is a preview of intent, not a guarantee of the final pixels, so keep a human or an automated check between Fast and full. Skipping that check is how teams end up paying for finals they reject.

Cache accepted shots

The cheapest generation is the one you do not run. Once a shot is accepted, store it keyed by the inputs that define it:

import hashlib, json

def shot_key(model, prompt, duration, aspect, resolution, image_sha=None):
    payload = json.dumps(
        [model, prompt, duration, aspect, resolution, image_sha],
        sort_keys=True,
    )
    return hashlib.sha256(payload.encode()).hexdigest()

def get_or_generate(store, submit_and_wait, **params):
    key = shot_key(**params)
    hit = store.get(key)
    if hit:
        return hit            # already paid for, no new job
    url = submit_and_wait(**params)
    store.put(key, copy_to_own_storage(url))
    return store.get(key)

Copy the file to your own storage when the job completes instead of keeping only the provider URL. Use the image hash in the key for image-to-video so a swapped source image is not served a stale clip. Caching also protects you from the most common double-spend: a user pressing "regenerate" on an unchanged request.

Gate the expensive tier per key and per user

• Model allow-list per API key. Give the draft-facing key only Lite and Fast. A request for a model outside the list returns 403 model_not_allowed, so a bug cannot silently burn money on the flagship.
• Monthly spend cap per key. Hitting it returns 402 spend_cap_exceeded, which your app should surface as "limit reached" rather than retrying.
• Application-level gating. Put full Veo 3.1 behind a paid plan, an explicit "final render" button, or an approval step, and show estimated cost before the click.

See the quickstart for the key setup.

Avoid paying twice by design

The opt-in failover.on_timeout_sec option resubmits a stalled job to another host without cancelling the original, and both attempts are billed if both land. That can be worth it for a deadline-critical final. It is a poor default for drafts, where waiting longer is cheaper than hedging. Likewise, retry loops on your side should key off failed or specific error codes, never off a slow job, because a slow job is still running and still billed.

A minimal budget guard

Track estimated spend per project before submitting. You can compute an estimate from the live per-second price and the requested duration, and refuse the call if it would exceed the project budget. Combined with the allow-list and cap above, that gives three independent layers: your app, the key, and the account balance. The numbers belong in your config or your finance sheet, not in prose, so pull them from the live pricing page when you set it up. Create a key at videorouter.sh/signup and start with the draft stage.

Frequently asked questions

Keep reading

• Veo 3.1 vs Veo 3.1 Fast vs Lite — Which to Call from Your API
• Veo API Without Google Cloud: What You Skip and What You Keep
• Veo 3.1 Image-to-Video API: Request Shape and Workflow
• How to Call the Veo 3.1 API: curl, Python and Error Handling