Veo 3 Fast vs Quality vs Lite — which video tier for which job

Veo 3 isn't one model on Brievio — it's three. Lite, Fast and Quality share the same endpoint and the same request shape, but they sit at very different price points: roughly $0.15, $0.25 and $1.20 per video. That's an 8× spread. Picking the wrong tier means either burning your budget on drafts nobody will ever publish, or shipping a hero ad that looks like a draft.

This is the practical version of "which tier for which job." No marketing adjectives — just what each one is genuinely good at, the real per-video cost, and a clear rule for when to reach for it. All three are the genuine Google Veo model served via Vertex, with native audio, 9:16 vertical for social, and image-to-video with first/last-frame control. The only thing you change between them is one string.

The three tiers at a glance

• Veo 3 Lite — ~$0.15/video. The budget tier. Use it to iterate: storyboards, prompt exploration, rough drafts, internal animatics. At fifteen cents a clip you can run twenty variations of a shot and pick the one that works before you spend real money rendering it well.
• Veo 3 Fast — ~$0.25/video. The best-value tier and the one most people should default to for published work. It carries native audio and a genuinely cinematic look at a quarter the cost of Quality. This is your social workhorse: Reels, TikTok, Shorts, product loops, ad variations you'll A/B test.
• Veo 3 Quality — ~$1.20/video. The top of the range, for when fidelity is the whole point. Reserve it for hero shots: the one ad that runs everywhere, the brand film, the landing-page loop people will scrub frame by frame. It costs ~5× Fast, so you spend it deliberately, not by default.

Every price above is per generated video on Brievio — roughly 37.5% under the official rate, pay-as-you-go, and failed calls are free. You only pay for clips that actually come back. See the live numbers on /pricing.

Same call, one string changes

The reason tiering is so low-risk is that switching is a one-line edit. You write your pipeline once and choose the tier per call by setting model to veo-3-lite, veo-3-fast, or veo-3-quality. Here's a text-to-video call, vertical for social:

import requests, os

KEY = os.environ["BRIEVIO_API_KEY"]

# Pick the tier with the model slug. Same endpoint, same request shape —
# only "model" changes between Lite, Fast and Quality.
resp = requests.post(
    "https://api.brievio.com/v1/video/generations",
    headers={"Authorization": f"Bearer {KEY}"},
    json={
        "model": "veo-3-fast",   # veo-3-lite | veo-3-fast | veo-3-quality
        "prompt": (
            "Handheld shot of a barista pouring latte art in a sunlit cafe, "
            "steam rising, warm morning light, ambient chatter and the hiss "
            "of the espresso machine. Cinematic, shallow depth of field."
        ),
        "aspect_ratio": "9:16",  # vertical — Reels / TikTok / Shorts native
    },
    timeout=600,   # generations run 30s to a few minutes; keep a long timeout
)
resp.raise_for_status()
data = resp.json()
print(data["data"][0]["url"])   # permanent files.brievio.com URL

The response is OpenAI-style: { data: [{ url: '...' }] }. The URL is permanent, served from files.brievio.com — download it into your own storage once if you need long-term hosting. Because the request shape is identical across tiers, your draft loop and your final render can be the exact same code path with a different model slug — start on Lite, promote the winner to Fast or Quality.

Image-to-video: anchor the frame, control the result

Text-to-video is great for exploration, but the moment you need on-brand, repeatable output — a specific product, a specific character, a specific composition — you anchor with an image. Pass an image_url and Veo 3 animates forward from it. One image is the first frame; two images give you first and last frame control, which is how you nail a precise start and end pose:

# Image-to-video: anchor the first frame with your own still, then let
# Veo 3 animate forward. This is where you get on-brand, controllable output.
resp = requests.post(
    "https://api.brievio.com/v1/video/generations",
    headers={"Authorization": f"Bearer {KEY}"},
    json={
        "model": "veo-3-quality",   # hero / ad — best fidelity
        "prompt": "The product slowly rotates as the light sweeps across it, then settles",
        "image_url": "https://files.brievio.com/<your-upload>.jpg",
        "image_mode": "frame",      # one image => first frame; two => first + last
        "aspect_ratio": "16:9",
    },
    timeout=600,
)
print(resp.json()["data"][0]["url"])

This is the call you usually reach for on the Quality tier, because the reason you went to the trouble of anchoring a frame is that fidelity matters for this shot. For draft iterations of the same idea, run the identical request on veo-3-lite first — same anchor image, same prompt, a fraction of the cost — and only render the keeper on veo-3-quality. The native audio comes along on every tier, so a Fast or Lite draft still tells you whether the timing and the sound land before you pay for the finish.

Pick this tier when…

The decision is almost always about where the clip is going:

• Pick Lite when nobody will see this exact render. Storyboards, animatics, prompt A/B exploration, "does this idea even work" tests. You're buying iterations, not polish. At ~$0.15 you can afford to be wrong twenty times.
• Pick Fast for anything you'll actually publish to social. Reels, TikTok, Shorts, product loops, UGC-style ads, and every variation you'll test against each other. Native audio, cinematic look, vertical-native — at ~$0.25 the cost basically disappears against the value of shipping more variants. This is the right default for most teams.
• Pick Quality only for hero work. The one ad that runs on paid everywhere, the brand film, the above-the-fold landing loop, anything that'll be viewed full-screen on a big display. At ~$1.20 it's ~5× Fast, so spend it on the handful of shots where the extra fidelity changes the outcome — not on the fiftieth A/B variant.

A pattern that works well in practice: draft on Lite, ship on Fast, finish hero shots on Quality. Most of your volume lives on Lite and Fast; Quality is the rare deliberate spend. Because the request is identical, that whole ladder is one variable in your config.

The honest tradeoffs

A few things worth being clear-eyed about before you commit a budget:

• Cost scales faster than perceived quality. The jump from Lite to Fast is a big visible upgrade for a dime. The jump from Fast to Quality is a smaller visible upgrade for ~$0.95. On a phone screen in a feed, most viewers can't tell Fast from Quality — which is exactly why Fast is the social default and Quality is reserved for big screens and paid placements.
• Generation isn't instant on any tier. Expect 30 seconds to a few minutes; the HTTP response is synchronous, so set a long client timeout (the snippets use 600s). Quality can take longer than Lite for the same prompt.
• Failed calls are free, so iterate without fear. A 4xx/5xx generation is never billed. That changes how you work: throw a lot of prompts at Lite, keep what lands, and don't treat a failed render as a sunk cost.
• Vertical is first-class. Set aspect_ratio: "9:16" and you get mobile-native framing without cropping — the same on all three tiers.

Where to go next

If you haven't made a video call yet, the Veo 3 & Sora API quickstart walks through setup, the file-upload step for anchor images, and the Node version of these calls. For the live per-video price on each tier — and every other video model in the catalog — see /models and /pricing.

The short version: default to Fast. Drop to Lite when you're iterating and nobody will see the render, and climb to Quality only for the handful of hero shots where fidelity is the point. One endpoint, one string, three budgets — choose per shot, not per project.