Veo 3.1 API: Which Model ID to Use, from $0.08 per 8-Second Clip
For most Veo 3.1 work through an API, the short version is this: use veo-3.1-fast-fhd by default ($0.088 for an 8-second 1080p clip with audio), drop to veo-3.1-fast-hd ($0.08, 720p) when someone is waiting and 720p is enough, and keep veo-3.1, Google's standard tier, for the final cut at $1.00 a clip. Plan for a median of about three and a half minutes per 1080p Fast clip, and poll or use a webhook instead of holding a connection open. The rest of this post backs each of those points with numbers.
Disclosure up front: the numbers below come from apimodels.app, which is the API I work on. apimodels.app is a multi-model API gateway: one API key and one OpenAI-compatible endpoint for image, video, audio and language models. Timings and failure rates are measured on our production traffic over the last 7 days (sample size not disclosed) and rounded; prices are what our billing charges as of October 27, 2026.
Which Veo 3.1 id for which job
All three ids share one endpoint and one request body; only the model field changes. Every clip is 8 seconds long and carries an audio track generated with the picture.
| Model id | Tier | Output | Price per clip | Per second of video |
|---|---|---|---|---|
| veo-3.1-fast-hd | Fast | 720p | $0.08 | $0.010 |
| veo-3.1-fast-fhd | Fast | 1080p | $0.088 | $0.011 |
| veo-3.1 | Standard | 1080p | $1.00 | $0.125 |
- veo-3.1-fast-fhd is the one to start with. It suits social clips, ad variations, animated product photos and any batch where you render several takes and keep the best. It costs only $0.008 more than 720p.
- veo-3.1-fast-hd is the quick one. It finishes in a little over half the time of the 1080p Fast tier, which suits in-app previews, internal review and placements shown small anyway.
- veo-3.1 is Google's standard tier, with better detail, motion and prompt adherence than Fast, at a little over eleven times the price. Use it for the clip that ships, once the prompt and first frame are settled on Fast.
Image input works the same on all three. Pass one image URL in images to use it as the first frame, or two to get a transition from the first frame to the last. Leave images out for plain text-to-video. Aspect ratio is 16:9 (the default) or 9:16. There is no duration or resolution parameter; if you send one, it is ignored.
What a request looks like
Video is asynchronous: you create a task, then poll it or receive a webhook. The example below is written against our API docs but was not run for this post, so treat it as an example and swap in your own key and image URL.
import os
import time
import requests
API = "https://api.apimodels.app/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['APIMODELS_API_KEY']}"}
# 1. Create the task (same body for all three ids)
created = requests.post(f"{API}/video/generations", headers=HEADERS, timeout=60, json={
"model": "veo-3.1-fast-fhd",
"prompt": "Slow push-in on a ceramic mug on an oak table, steam rising, "
"soft morning light, quiet cafe ambience",
"aspect_ratio": "16:9", # or "9:16"
"images": ["https://example.com/mug-first-frame.jpg"], # optional: [first] or [first, last]
# "callback_url": "https://your-app.example/hooks/veo", # webhook instead of polling
}).json()
if created.get("code") != 200:
raise RuntimeError(created.get("msg"))
task_id = created["data"]["taskId"]
# 2. Poll. The 1080p p90 is just over 5 minutes, so allow 15.
deadline = time.time() + 15 * 60
while time.time() < deadline:
data = requests.get(f"{API}/video/generations", headers=HEADERS,
params={"task_id": task_id}, timeout=30).json()["data"]
if data["state"] == "completed":
print("video:", data["resultUrls"][0])
break
if data["state"] == "failed":
print("failed:", data["failCode"], data["failMsg"], "retryable:", data["retryable"])
break
time.sleep(10)
# 3. Exact charge in USD (0 for a failed task)
record = requests.get(f"{API}/records/{task_id}", headers=HEADERS, timeout=30).json()["data"]
print(record["state"], record["credits"], record["currency"])
In production, pass callback_url instead of polling: when the task completes or fails, we POST its state, result and final charge to that URL. Result files are kept for 30 days.
How long a clip takes
Time from submit to finished clip, successful requests only, including queueing and any automatic rerouting:
| Model id | p50 (s) | p90 (s) |
|---|---|---|
| veo-3.1-fast-hd (720p) | 117 | 190 |
| veo-3.1-fast-fhd (1080p) | 205 | 311 |
| veo-3.1 (standard) | not enough data | not enough data |
- 720p is the fast lane. The median 720p Fast clip arrives about 90 seconds before the 1080p one, which a user watching a progress bar will notice.
- Do not give up at five minutes. The 1080p p90 is just over 300 seconds, so a five-minute client deadline would throw away more than one in ten clips that were about to succeed. Give polling 15 minutes, or use the callback.
- Aspect ratio barely matters. On the 1080p Fast tier, 16:9 and 9:16 clips land about ten seconds apart at the median and at the same time at p90.
- The standard tier did not see enough traffic this week for honest percentiles; plan for at least as long as 1080p Fast.
Failures, retries and what you are billed
Over the same 7 days, about 8% of Fast-tier requests were refused by content moderation, and fewer than 1% failed for any other reason. A moderation refusal is final; resending the same request gets the same answer.
Failures come with a standard failCode and a retryable flag. CONTENT_MODERATION and INVALID_INPUT are not retryable; change the prompt or the parameters instead. UPSTREAM_BUSY, UPSTREAM_FAILED and TIMEOUT are, and one or two retries a few seconds apart are enough.
Both Fast ids have more than one upstream route. If the first route errors or times out, the task moves to the next one without any action from you. Fewer than 1 in 100 Fast requests needed that backup route this week, and most of those still finished. The standard veo-3.1 tier runs on a single route today, so your own retry policy matters more there.
Failed tasks are not billed: the amount reserved at creation is released, and the poll response and callback report credits as 0. For reconciliation, GET /v1/records/{task_id} returns the final state and exact charge of any task, so matching a batch against your own logs is one loop.
What comes back, and one caveat on 1080p
Every successful clip in the window whose length we recorded was 8 seconds, and the MP4 already contains the audio track.
One caveat on veo-3.1-fast-fhd: when 1080p capacity is short, its backup route renders at 720p, so the task finishes instead of failing. That happened to fewer than 1% of fast-fhd clips in the last 7 days. If you must publish 1080p, check each file's real dimensions and regenerate the rare 720p one. veo-3.1-fast-hd has no such caveat, because its backup route renders 720p as well.
Prices, and how they compare with Google
Prices are flat per 8-second clip, and no price change is scheduled. Google bills Veo 3.1 per second of output. Its standard rate for the Standard tier is $0.40 per second with audio, so an 8-second clip costs $3.20 at list. On apimodels.app the same 8-second 1080p clip on veo-3.1 is $1.00, 69% below that list price.
The Fast tiers are $0.08 (720p) and $0.088 (1080p) per clip, which is $0.010 and $0.011 per second of finished video. Beyond price: no Google Cloud project or billing account to set up, one key for every other model on the gateway, pay-as-you-go billing, and failed tasks cost nothing. All parameters and the current price table are on the Veo 3.1 API reference.
A worked cost estimate
Say a shop with 300 products wants one 8-second clip per product, animated from the existing product photo, plus 10 hero clips for the homepage, and you render two takes of everything to keep the better one:
Product clips 300 x 2 x $0.088 (veo-3.1-fast-fhd) = $52.80
Hero clips 10 x 2 x $1.00 (veo-3.1) = $20.00
Total $72.80
At Google's list rate, the 20 standard-tier takes alone would be 20 x $3.20 = $64.00. Refused or failed takes are not billed, so for the same number of attempts the bill can only land at or below this. With a 1080p median of about three and a half minutes, submit the 600 product takes with a callback_url instead of waiting on each in turn.
When not to use it
- You need 4K or clips longer than 8 seconds. No Veo 3.1 tier here outputs 4K, and every clip is 8 seconds. Older ids with "4k" in the name, such as veo3.1-4k, still resolve, but they are aliases of veo-3.1-fast-fhd and return 1080p at $0.088.
- You need guaranteed 1080p with no checking step. The fast-fhd caveat above is rare but real. If you cannot add a dimension check, use veo-3.1, which always renders 1080p, and handle retries yourself.
- A user needs the clip in seconds. Even the 720p Fast tier has a median close to two minutes.
- You need seeds, negative prompts or other fine controls. Besides the prompt, the request takes an aspect ratio and up to two frames; there are no seed or negative-prompt fields.
- You need a direct contract with Google, for enterprise terms, Vertex AI features or committed spend. Use Google's own API.
If none of those apply, the quickest test is one $0.08 veo-3.1-fast-hd text-to-video request; the task and its exact charge then show up under Records in the apimodels.app console.
Drafted with AI assistance; prices and numbers checked against our API docs and records on Oct 25, 2026.
评论
发表评论