The most expensive mistake in a Veo 3 integration is not a wrong parameter. It is a wrong model ID. Google retired veo-3.0-generate-001 and veo-3.0-fast-generate-001 on June 30, 2026 — the same day it retired Veo 2 — and its deprecations table now names veo-3.1-generate-preview as the replacement for both. If you came here for Veo 3 API documentation, that single line is the difference between a working integration and a 404. On September 13, 2026 we pulled page one for the query that gets you here: of the nineteen organic results, eight were aggregator or reseller pages, and several of those still present “Veo 3” as a product you can buy as named — including one listing that still advertises the retired 3.0 model.
This page is the reference for what “Veo 3 API documentation” means today, verified against first-party sources on September 13, 2026: the live model IDs, the submit and poll endpoints, the complete request schema including the two mutually exclusive image-video modes, the error codes and which ones to retry, and the per-second rates with a worked 8-second example. One disclosure up front, because it belongs up here rather than in a footer: Modellix operates this blog and routes media models behind one API key, so we have a commercial interest in the aggregator half of what follows. We also do not carry Veo 3.0 — those routes were retired from our catalogue on August 27, 2026 — so nothing below is an attempt to sell you one.
What the Veo 3 API is today: two live tier names and one retired model ID
Google’s own deprecations table is the authority here, and it is unambiguous. veo-3.0-generate-001 shipped September 9, 2025 and was shut down June 30, 2026, with veo-3.1-generate-preview listed as the recommended replacement; veo-3.0-fast-generate-001 went the same day to veo-3.1-fast-generate-preview. The two earlier preview IDs, veo-3.0-generate-preview and veo-3.0-fast-generate-preview, had already been retired on November 12, 2025. The three IDs that answer today are veo-3.1-generate-preview, veo-3.1-fast-generate-preview and veo-3.1-lite-generate-preview, and none of them carries a shutdown date. That is the whole status question, and it takes about fifteen seconds to check — which is worth doing before you accept any parameter table, including the one below.
| Model ID | Released | Shutdown | Google’s stated replacement |
|---|---|---|---|
veo-3.1-generate-preview |
October 15, 2025 | none announced | — |
veo-3.1-fast-generate-preview |
October 15, 2025 | none announced | — |
veo-3.1-lite-generate-preview |
March 31, 2026 | none announced | — |
veo-3.0-generate-001 |
September 9, 2025 | June 30, 2026 | veo-3.1-generate-preview |
veo-3.0-fast-generate-001 |
September 9, 2025 | June 30, 2026 | veo-3.1-fast-generate-preview |
veo-2.0-generate-001 |
April 9, 2025 | June 30, 2026 | veo-3.1-generate-preview |
Two boundaries are worth stating plainly, because they change what you can build. First, the Gemini API is no longer where Google points video generation by default: its video overview now tells developers to “use Gemini Omni Flash as your default model for video generation” and keeps Veo 3.1 for scene extension, last-frame control and legacy pipelines. Second, Vertex AI and the Gemini Enterprise Agent Platform are a different integration surface from the Gemini API — the same model family, different endpoints, different price sheet. Everything from here on describes the REST API at a single base URL, not the Agent Platform’s models.predict.
Modellix mirrors that picture rather than papering over it. Our catalogue on September 13, 2026 lists 178 live models in total and exactly six Veo routes, all of them 3.1 — google/veo-3.1-t2v, google/veo-3.1-i2v, google/veo-3.1-fast-t2v, google/veo-3.1-fast-i2v, google/veo-3.1-lite-t2v and google/veo-3.1-lite-i2v, all of them filed under text-to-video (the three -t2v routes) or image-to-video (the three -i2v routes). The four google/veo-3-* routes are gone from it, retired on August 27, 2026 and listed by ID in our deprecated models changelog. The Veo 3 series page still exists as a family landing page, and the routes that actually answer live under the Veo 3.1 series and the Google provider page.
Veo 3 API endpoint reference: one base URL and why you will see two spellings
Every media call goes to the same host, with your key in an Authorization: Bearer header. There are five endpoints you will actually touch:
| Purpose | Method and path |
|---|---|
| Submit a generation task | POST https://api.modellix.ai/api/v1/{provider}/{model} |
| Fetch a task result | GET https://api.modellix.ai/api/v1/tasks/{task_id} |
| Per-request cost log | GET https://api.modellix.ai/api/v1/logs |
| Discover model slugs | GET https://api.modellix.ai/api/v1/models |
| Upload an input file | POST https://api.modellix.ai/api/v1/media/files |
If you have read an older tutorial, you may have seen the submit path written as .../{model}/async. Both work, and that is not a typo in either place. On June 11, 2026 Modellix removed the /async suffix from every model invocation path — POST /alibaba/qwen-image-edit-plus/async became POST /alibaba/qwen-image-edit-plus — and shipped full backwards compatibility at the same time. The changelog wording is explicit: “If you are currently using the /async endpoints, your integrations will not be affected.” So POST https://api.modellix.ai/api/v1/google/veo-3.1-t2v is the path to write today, and an existing /async client is not broken. What is broken is an ID like veo-3.0-generate-001 — that is a model retirement, not a path change, and no compatibility layer brings it back.
The request body field by field: T2V, and the I2V oneOf
Text-to-video is the simple case. The published schema for google/veo-3.1-t2v takes six fields, one of them required:
| Field | Type | Required | Accepted values |
|---|---|---|---|
prompt |
string | Yes | free text, minimum length 1 |
negativePrompt |
string | No | free text |
aspectRatio |
string | No | 16:9 (default), 9:16 |
duration |
string | No | "4", "6", "8" — note the type |
resolution |
string | No | 720p (default), 1080p, 4k |
personGeneration |
string | No | allow_all (text-to-video) |
Three details in that table cost people time. duration is a string, not an integer — "8" works, 8 is a parameter error. resolution: 1080p and resolution: 4k are only valid at 8 seconds, so a 4-second 1080p request is rejected rather than silently downgraded. And personGeneration is a single-value enum here: text-to-video accepts allow_all; image-to-video, interpolation and reference-image modes accept allow_adult only, and in EU, UK, CH and MENA locations allow_adult is the only value anywhere.
Image-to-video is where the schema stops being a flat list of fields. The google/veo-3.1-i2v request is declared as a oneOf with two mutually exclusive shapes, and the schema says so in as many words: “Choose one option — image mode and referenceImages mode are mutually exclusive.”
| Image mode | Reference mode | |
|---|---|---|
| Required | prompt + image |
prompt + referenceImages |
| Optional | lastFrame, negativePrompt, personGeneration, aspectRatio, duration, resolution |
personGeneration, aspectRatio, duration, resolution |
duration |
"4", "6", "8" — but "8" if you pass lastFrame |
"8" only |
negativePrompt |
supported | not supported |
| Availability | google/veo-3.1-i2v and -fast-i2v (the two routes this table’s oneOf covers); google/veo-3.1-lite-i2v also takes image/lastFrame with a flat schema |
Veo 3.1 and Veo 3.1 Fast I2V only |
referenceImages takes up to three image URLs and exists to preserve a subject’s appearance across shots. The constraints are enforced upstream, not by us: duration must be exactly "8" in reference mode, lastFrame only works at "8", and 4K costs more because it only runs at that length. A minimal image-mode call looks like this:
1 | curl --request POST \ |
Swap in "lastFrame": "https://file.modellix.ai/example/last-frame.png" and you get an interpolation between the two frames; swap image for "referenceImages": ["...", "..."] and you get reference mode — remembering to delete negativePrompt and pin duration to "8".
How to get an authoritative Veo 3 API documentation schema without an API key
Here is the part most parameter tables leave out: those fields are not stable enough to memorise, and the ones in this article will be as stale as the next aggregator’s the moment Google changes a constraint. So the workflow worth adopting is to fetch the contract instead of memorising it.
The schema endpoint is public and requires no authentication: GET https://www.modellix.ai/models/{model_slug}/api_schema, documented in the Get Schema reference. Pass the slug in provider/model form with the slash as a literal path separator, and you get back an OpenAPI-style fragment — the model description, the JSON Schema for the request body, examples, and the async task responses. Use servers[0].url as the URL to POST to, and remember that the generate call itself still needs your Bearer key.
If you would rather stay in the terminal, the CLI does the same lookup and skips the key requirement:
1 | npm install --global modellix-cli@latest |
--output human prints a readable summary of the contract, and --quiet prints just the inference URL. This is the same path Modellix’s own agent Skill and Plugin use before a non-trivial submit — the changelog entry for September 4, 2026 puts the reasoning well: they read request-body schemas this way “instead of guessing from documentation”. Slugs for model get-schema come from modellix-cli model list, or from GET /api/v1/models, which returns each model’s slug, type, docs_url and a description.
The schema endpoint is public: the page states the endpoint does not require an API key, and that only the servers[0].url generate call does. Captured September 13, 2026.
Media API Reference
See the async task format, polling endpoint and result retrieval for every model, including the six Veo 3.1 routes.
View DocsSubmit, poll, and read the async response
Generation is asynchronous: you submit, you get a handle, you poll. The submit response has four fields worth knowing by name.
1 | { |
code: 0 means accepted, not finished — status starts at pending and moves through processing. The value you should actually use is get_result.url, because it is the authoritative poll address; building the URL yourself from task_id works today but assumes a URL shape the API has no obligation to keep. Poll until the task reaches a terminal state, of which there are three: success, failed and canceled. On success the payload carries result.resources[] with the asset URL, result.extensions.submit_time and end_time, and a billing block with the charged amount.
The three stages above as a pipeline: one submit, one handle, one terminal state — the same shape as the submit → poll → retrieve cycle in the code. Generated illustration, September 13, 2026.
Do not poll on a fixed two-second timer. Google’s own documentation for Veo 3.1 gives a latency band of 11 seconds minimum to 6 minutes maximum during peak hours, so a tight loop mostly buys rate-limit pressure. A 5-to-10 second interval with a cap — and a webhook, below — is the sane configuration.
Error handling: seven status codes and which ones to retry
Errors come back in one shape, {"code": <http status>, "message": "<Category>: <detail>"}, so a single parser handles all of them. What matters operationally is which codes are retryable:
| Status | Meaning | Retry? |
|---|---|---|
| 400 | Invalid parameters — missing required field, wrong type | No. duration: 8 instead of "8" lands here |
| 401 | Invalid, missing or expired API key | No |
| 402 | Insufficient balance or account in arrears | No — top up |
| 404 | Task ID, model or provider not found | No. A retired Veo 3.0 ID lands here |
| 429 | Rate limit or concurrent-task limit exceeded | Yes — exponential backoff |
| 500 | Internal processing error | Yes — up to 3 attempts |
| 503 | Service temporarily unavailable | Yes — with backoff |
For 429 the response carries X-RateLimit-Limit, X-RateLimit-Remaining and X-RateLimit-Reset; read the reset header rather than guessing at a sleep. For 500 and 503 the documented pattern is 1s → 2s → 4s. And note what is not on that list: a failed render is not a failed request. If Veo 3.1 blocks a video because of safety filters or a problem with the generated audio, you are not charged.
Polling is not the only delivery mechanism. Any submit call can carry an X-Webhook-URL header, and Modellix will POST the terminal payload to your HTTPS endpoint with X-Modellix-Event set to prediction.task.succeeded, prediction.task.failed or prediction.task.canceled, plus X-Modellix-Task-ID, X-Modellix-Delivery-ID and X-Modellix-Retry-Count. Your receiver must return 2xx; 429, 5xx, timeouts and temporary network errors are retried, while 3xx and other 4xx are not. Deduplicate on X-Modellix-Delivery-ID — retries are real deliveries. Localhost and private IPs are rejected, so testing needs an ngrok-style tunnel, not a loopback address.
On throughput, the limits scale with a single top-up rather than with account age: under $10 gets you 2 concurrent tasks and 100 requests per minute, $10 gets 10 and 100, $100 gets 20 and 200, and the ladder runs to 100 concurrent tasks and 1,000 RPM at $1,000. The current numbers live on the entitlements page. For rate-limit behaviour you can also set a low-balance email alert in the console, which is cheaper than discovering a 402 in production.
Image inputs and the File API’s seven-day window
Reference and image-to-video modes both need a picture that something else can fetch. You can host it yourself, or upload it once and let the API serve it: POST /api/v1/media/files with multipart/form-data and the field name file returns a file_id, a type and a url you can pass straight into the image field. Uploads are authenticated with the same key, free of charge, and scoped to your team.
The constraints are the load-bearing part, because one of them is a hard limit rather than a quota:
- Retention is about 7 days. Uploaded files expire; generated results are also only kept for 7 days on our side (Google keeps its own rendered videos for 2 days). Anything you need permanently must be copied to your own storage.
- 16 MB maximum file size, with
jpg,jpeg,png,webp,gif,bmp,tiff,tif,heic,heifand the rest of the documented list accepted for images. - 10 files per team and 2 concurrent uploads by default. Delete files you no longer need — deletion frees the quota immediately — rather than treating the File API as storage.
A 7-day window is fine for a pipeline that uploads and submits in the same job, and wrong for anything that treats the upload as a durable asset. Plan accordingly rather than discovering it on day eight.
What a Veo 3.1 call costs, and a worked 8-second example
Veo bills per second of output, and the rate depends on resolution. These are the four live text-to-video and image-to-video rates we pulled from the catalogue on September 13, 2026, alongside the Google list price the catalogue shows for comparison:
| Route | 720p | 1080p | 4K | Google list (720p / 1080p / 4K) |
|---|---|---|---|---|
google/veo-3.1-t2v |
$0.3600/sec | $0.3600/sec | $0.5400/sec | $0.40 / $0.40 / $0.60 |
google/veo-3.1-fast-t2v |
$0.0900/sec | $0.1080/sec | $0.2700/sec | $0.10 / $0.12 / $0.30 |
google/veo-3.1-lite-t2v |
$0.0450/sec | $0.0720/sec | not supported | $0.05 / $0.08 / — |
google/veo-3.1-i2v |
$0.3600/sec | $0.3600/sec | $0.5400/sec | $0.40 / $0.40 / $0.60 |
Arithmetic makes the tier choice concrete. One 8-second clip at 1080p costs $2.88 on veo-3.1-t2v, $0.864 on the Fast route and $0.36 on Lite at 720p — a spread of roughly eight times for the same clip length, decided entirely by the route you name. The same clip at 4K is $4.32 on the standard route. That is the only cost lever with this much range, which is why the model ID belongs in configuration rather than in application logic. Google’s own rates are published on its Gemini API pricing page, and the comparison column above is the catalogue’s, not an independent measurement of Google’s billing.
The same numbers in their native form: the google/veo-3.1-t2v model page lists prompt through resolution in the parameter table and prices 720p and 1080p at 0.3600 and 4K at 0.5400 under Unit: $/sec. Captured September 13, 2026.
Listed rates are not the whole bill story, so here is the part that is genuinely useful for a finance conversation. GET /api/v1/logs returns per-request rows with the task_id, the model, the status, the wall duration in milliseconds, the recorded input, and a cost field measured in sub-pennies — 1 equals $0.0001, so divide by 10,000 for dollars and a row reading cost: 12 is $0.0012. The window can be at most 30 days, and an optional mdlx_user_id filter matches the X-Mdlx-User-Id header you set on submit, which is how you attribute spend to your own end users. The full field list is in the logs reference.
Two pricing notes that are easy to conflate and worth keeping apart. First, a register-level discount is not a unit price: Modellix offers a 10% first-purchase discount on a top-up tier (every tier, once) — that is money off a payment, and it is a different thing from the per-second $/sec figures in the table above, which are the price of the model itself. Second, there is no free tier to plan around: new accounts no longer receive signup credit as of August 19, 2026, when the $1 complimentary credit was withdrawn, and trial credit is now requested by email from support.
Check Current Veo 3.1 Rates
Log in to see per-resolution rates for all six Veo 3.1 routes on one key — and the per-request cost log behind them.
LoginFAQ
Is there free Veo 3 API access?
No. Google’s pricing page lists the free tier for every Veo 3.1 model as “Not available”, and the API has never had one. On the aggregator side there is no signup credit either: the $1 complimentary credit was withdrawn on August 19, 2026, and trial credit is now requested by email from Modellix support rather than granted automatically at registration.
Can I still call veo-3.0-generate-001?
Not through Google. The model was shut down on June 30, 2026, along with veo-3.0-fast-generate-001, and a shut-down Gemini model has its endpoint removed. A third-party listing that still advertises Veo 3 under that name is either selling leftover capacity under a private alias or has not updated its page; either way the model code is no longer a Google code.
Do I need a different API key for Veo 3.1?
No. The key, the base URL and the submit-poll lifecycle are unchanged from Veo 3.0. You are changing a model ID, which is exactly why the ID should live in configuration — if you are still deciding where the key itself should come from, our Veo 3.1 API key guide covers that path separately.
What is the JSON body for a minimal Veo 3 call?
For text-to-video, one field is enough: {"prompt": "A majestic eagle soaring over snow-capped mountain peaks at sunrise"}. To pin quality, add "aspectRatio": "16:9", "duration": "8" and "resolution": "1080p" — remembering that duration is a string, and that 1080p and 4K are only valid at 8 seconds.
Is there a Veo 3 API key generator?
No, and you should be wary of anything claiming to be one. Keys are created in the Modellix console under API Key and are shown once at creation, so save it then; Google issues its own keys through AI Studio. A “generator” that hands out keys is either a reseller proxy or a credential-harvesting page.
Why does my Veo 3 API request return 400 with a prompt error?
The most common causes are a missing prompt on an image-to-video call that should have supplied one, duration sent as the integer 8 instead of the string "8", resolution: "1080p" combined with a 4-second duration, and negativePrompt sent in reference mode where it is not supported. The message follows the Category: detail format, so read the detail rather than matching on the code alone.
How long do generated videos stay available?
On the Google side, rendered videos are stored for two days; on the Modellix side, generated results and uploaded input files are retained for about 7 days. Neither is storage. Download the asset when the task completes and copy it somewhere you control. One related detail worth knowing before you ship output to customers: Google watermarks every Veo result with SynthID, its AI-content watermark, so generated video can be identified as generated downstream.
Where do I find the Veo 3 API documentation for a specific route?
Each route has its own reference page — the Veo 3.1 T2V page is the one for text-to-video — and the same contract is machine-readable from GET https://www.modellix.ai/models/{model_slug}/api_schema or modellix-cli model get-schema <slug>, neither of which needs an API key. For a wider view of what a video pipeline costs beyond one tier, our Veo 3.1 price breakdown works through the tier-by-tier comparison.
The habit that outlives this page
Model IDs retire on other people’s schedules. Veo 2 and both Veo 3.0 IDs all stopped answering on the same day in June 2026, and the integrations that survived it were the ones where the ID was a configuration value and the request schema was fetched rather than remembered. That is the durable part of this documentation: not the field list — which will drift, and which you can now re-pull in one command — but the three habits underneath it. Keep the model ID out of your code. Fetch the schema instead of trusting a table. And log the per-request cost from day one, so the first conversation about spend is a query rather than an argument.
We should be explicit about what we are not claiming here. This page is not an argument that one platform’s Veo rates beat another’s — we have not benchmarked competitors’ billing, some of them quote per-clip prices that cannot be compared to a per-second rate at all, and the comparison column above is our own catalogue’s. What we can show you is the contract and the receipts behind one key.
Endpoints, schema constraints, prices and catalogue status reflect first-party sources read on September 13, 2026: Gemini API deprecations, the Veo 3.1 guide, the Gemini API pricing page, the video generation overview, Modellix product updates, the deprecated models list, the REST API guide, and the logs reference. Model availability and per-second rates change without notice; validate against the live schema and the model page before committing a workload. Modellix operates this blog and routes image and video models behind one API key.
Re-pull the contract for whichever Veo 3.1 route you actually plan to ship — the schema is public, and the six live routes are all on the same key.
