MODELLIX editorial cover reading Veo 3.1 API over the subtitle Integration Guide, Pricing and Code, with a glass API gateway, request and polling nodes, and film-strip frames

Calls to the Veo 3.1 API follow one pattern no matter which model ID you send: submit a long-running operation with POST, poll it until it finishes, then download the video Google has generated. There are only three current model IDs to learn — veo-3.1-generate-preview, veo-3.1-fast-generate-preview, and veo-3.1-lite-generate-preview — all on the generativelanguage.googleapis.com/v1beta base URL, all authenticated with a single x-goog-api-key header, all billed per second of output with no free tier. This guide walks that request surface end to end as of September 8, 2026: the exact endpoints and parameters, runnable REST and Python examples, the tier-by-tier price table pulled from Google’s pricing page today, and the aggregator route that reaches the same models through one key when you do not want a per-vendor Google Cloud project. If you still need the key itself, our separate Veo 3.1 API key guide covers that path — this article assumes you have a working Gemini API key and billing enabled.

The Veo 3.1 API request surface: endpoints, model IDs, and auth

Veo 3.1 runs on the Gemini API, so the surface is the same as Google’s other media models: one base URL, model IDs in the path, and a key in the header.

Base URL and auth. The endpoint prefix is https://generativelanguage.googleapis.com/v1beta. Every request sends your Gemini API key either as an x-goog-api-key header (REST) or through the SDK’s environment-based client (the google-genai SDK reads GEMINI_API_KEY or GOOGLE_API_KEY). There is no separate Veo key — the billing gate is the Google Cloud project the key belongs to: Veo 3.1 is a paid preview, so a project without billing attached returns auth-style errors on every video call.

Model IDs — the three you can call today. Google’s Veo 3.1 documentation lists three preview models, and the differences that matter for cost and capability are resolution ceiling and whether reference images exist:

Model ID (Gemini API) Tier Output Reference images Status (deprecations page)
veo-3.1-generate-preview Standard up to 4K, native audio up to 3 Preview, no shutdown date
veo-3.1-fast-generate-preview Fast up to 4K, native audio up to 3 Preview, no shutdown date
veo-3.1-lite-generate-preview Lite 720p/1080p, native audio not supported Preview, no shutdown date

All three output 24 fps video at 4, 6, or 8 seconds in 16:9 or 9:16, with audio generated in the same pass — Google’s docs mark audio “always on,” which is why pricing below quotes only with-audio rates. Higher resolutions cost more and only run at the 8-second duration (details in the pricing section). Input prompt is capped at 1,024 tokens per the model card.

Which IDs are dead. The biggest source of 404s on this API is sending a model ID that used to work. Google’s deprecations page records that veo-3.0-generate-001, veo-3.0-fast-generate-001, and veo-2.0-generate-001 were shut down on June 30, 2026, and that the earlier veo-3.0-*-preview IDs were already replaced in late 2025. Anything you find online still teaching veo-3.0-* or veo-2.0-* calls is describing models that no longer answer. Aggregator aliases (for example veo-3.1-quality or veo3-fast on reseller sites) are not Gemini API IDs either — to reach Google directly, send the exact veo-3.1-*-generate-preview string.

One positioning note before the code: Google’s video generation overview now recommends Gemini Omni Flash as the default video model and positions Veo 3.1 for the cases where its specific capabilities matter — native cinematic audio, first/last-frame control, and video extension. If you are picking a video model from scratch rather than integrating a Veo pipeline specifically, read that page first.

Veo 3.1 API request lifecycle: a client submits a predictLongRunning operation, polls the returned operation ID, and downloads the generated video when it is done

Figure: the one pattern behind every Veo 3.1 API call — submit, poll, download. Concept diagram generated for this article, not a screenshot of the console.

Text-to-video: first request in REST and Python

Video generation is a long-running operation, not a synchronous call. The REST pattern below is the entire API in miniature: POST to the model’s :predictLongRunning endpoint, read the operation name from the response, poll GET on that operation until done: true, then take the video URI from response.generateVideoResponse.generatedSamples[0].video.uri and download it.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
BASE_URL="https://generativelanguage.googleapis.com/v1beta"
API_KEY="$GEMINI_API_KEY"   # export GEMINI_API_KEY=... before running

# 1. Submit the generation and capture the operation name
operation_name=$(curl -s "${BASE_URL}/models/veo-3.1-generate-preview:predictLongRunning" \
  -H "x-goog-api-key: ${API_KEY}" \
  -H "Content-Type: application/json" \
  -X POST \
  -d '{
    "instances": [{
      "prompt": "A lighthouse on a rocky coast at dusk, waves breaking against the cliff, warm light spilling from the lantern room"
    }],
    "parameters": {
      "resolution": "1080p",
      "aspectRatio": "16:9",
      "durationSeconds": "8"
    }
  }' | jq -r .name)

# 2. Poll until done
while true; do
  status=$(curl -s -H "x-goog-api-key: ${API_KEY}" "${BASE_URL}/${operation_name}")
  is_done=$(echo "${status}" | jq -r .done)
  [ "${is_done}" = "true" ] && break
  echo "Waiting for video generation to complete..."
  sleep 10
done

# 3. Download the video
video_uri=$(echo "${status}" | jq -r \
  '.response.generateVideoResponse.generatedSamples[0].video.uri')
curl -sL -H "x-goog-api-key: ${API_KEY}" "${video_uri}" -o veo31_clip.mp4

The same flow in Python with the google-genai SDK is shorter because the SDK wraps the operation lifecycle:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import time
from google import genai

client = genai.Client()  # reads GEMINI_API_KEY / GOOGLE_API_KEY from the environment

operation = client.models.generate_videos(
    model="veo-3.1-generate-preview",
    prompt="A lighthouse on a rocky coast at dusk, waves breaking against the cliff, warm light spilling from the lantern room",
    config=genai.types.GenerateVideosConfig(
        resolution="1080p",    # "720p" | "1080p" | "4k" (Lite: no 4k)
        aspect_ratio="16:9",   # or "9:16"
        duration_seconds="8",  # or "4" | "6"; must be "8" with 1080p/4k
    ),
)

while not operation.done:
    time.sleep(10)
    operation = client.operations.get(operation)

video = operation.response.generated_videos[0]
client.files.download(file=video.video, destination="veo31_clip.mp4")

The JavaScript (@google/genai), Go, and Java SDKs expose the same generateVideos operation-plus-poll shape, so the pattern transfers across languages. The parameter names in the SDK config map to the REST body below, which is worth memorizing because it is where first integrations usually break:

Parameter Where it lives Values Gotcha
prompt instances[0] string ≤ 1,024 tokens; supports audio cues (sound effects, ambience, dialogue)
image instances[0] image object starting frame for image-to-video
lastFrame instances[0] image object final frame; must be combined with image
referenceImages instances[0] up to 3 images Standard/Fast only — Lite returns an error
video instances[0] prior output video input for video extension; extension output is 720p only
aspectRatio parameters "16:9" (default), "9:16" —
durationSeconds parameters "4", "6", "8" must be "8" at 1080p/4K, with reference images, or for extension
resolution parameters "720p" (default), "1080p", "4k" 1080p/4K only at 8 s; Lite capped at 1080p
personGeneration parameters allow_all / allow_adult region-dependent — see the limitations note below

Image-to-video, frame control, reference images, and extension

Everything beyond plain text-to-video is the same endpoint with a different input object in instances[0] — there are no separate routes for these modes, which is the most useful fact to internalize before reading reseller pages that advertise them as distinct APIs.

  • Image-to-video: pass a starting image in image. Veo 3.1’s strength here is temporal consistency — it interpolates motion from the still rather than drifting into unrelated content.
  • First-and-last-frame (interpolation): pass both image and lastFrame. The model generates the transition between the two frames. This is the mode to use for storyboard transitions and A/B creative direction, but note the 8-second rule: interpolation and reference-image modes force durationSeconds: "8".
  • Reference images: up to three images in referenceImages steer style and subject consistency. Available on Standard and Fast only; sending them to Lite is an error. Google’s docs show the referenceImages field as n/a on Lite.
  • Video extension: pass a previously generated Veo video in video to continue it. Extension is limited to 720p output, and extended videos are treated as newly generated for billing and retention purposes.

One honest limitation from the Veo 3.1 docs worth quoting: reference-image and extension support is not universal across the lineup — Lite exists specifically as the no-frills tier (no 4K, no reference images, and no video extension), and if your pipeline needs subject consistency from references or video extension, that constraint alone selects Standard or Fast.

Four Veo 3.1 input modes feeding one model endpoint: text prompt, starting image, first-and-last-frame pair, and up to three reference images, plus video extension input

Figure: image-to-video, interpolation, reference images, and extension are inputs to the same predictLongRunning endpoint, not separate APIs. Concept diagram generated for this article.

Veo 3.1 API pricing, pulled September 8, 2026

Veo 3.1 is billed per second of generated video, and the rate depends on tier and resolution. Because audio is always on, Google publishes a single with-audio rate per tier and resolution — there is no separate no-audio price on the Gemini API pricing page today. These figures are the pricing page as I read it on September 8, 2026 (the page was last updated within days of this snapshot):

Tier (per second, with audio) 720p 1080p 4K
veo-3.1-generate-preview (Standard) $0.40 $0.40 $0.60
veo-3.1-fast-generate-preview (Fast) $0.10 $0.12 $0.30
veo-3.1-lite-generate-preview (Lite) $0.05 $0.08 not supported

Free tier: not available on any tier — the pricing page says so explicitly for all three. So the practical cost questions answer like this: an 8-second clip costs $3.20 on Standard 1080p, $4.80 on Standard 4K, $0.96 on Fast 1080p, or $0.40 on Lite 720p. An hour of generated video at Fast 720p is $360 — which is exactly why tier selection is a budget decision, not a quality decision, and why iteration workloads belong on Fast or Lite.

Read Google’s status with care. The pricing page’s model-status column has lagged reality before: it listed Veo 3.0 as stable for weeks after the June 30, 2026 shutdown was announced. Whenever a Veo version’s availability matters, cross-check the deprecations page (updated September 5, 2026): it records the three 3.1 preview models with no shutdown date announced, and the Veo 3.0/2.0 shutdowns above. And these Gemini API numbers are only one surface — the same Veo 3.1 line ships as a GA model (veo-3.1-generate-001) on Google’s Gemini Enterprise Agent Platform with provisioned-throughput pricing instead of pay-as-you-go. Say which surface you mean when you compare quotes. For the full cost analysis across clip lengths and both surfaces, our separate Veo 3.1 price deep dive has the complete table — this guide carries the numbers you need to budget an integration.

Calling Veo 3.1 through an aggregator: one key on Modellix

Direct Google access is the whole story if Veo is your only video model. The aggregator route exists for the situation where you want Veo 3.1 and other vendors’ models behind one key and one bill, without a Google Cloud project per vendor. A disclosure belongs here: Modellix operates this blog and has a commercial interest in you using its API. Take the numbers below as a same-day snapshot of Modellix’s own model pages, not a promise about any other aggregator — the same single-key pattern exists at platforms like Kie and OpenRouter with their own catalogs and price lists.

Modellix lists the Veo 3.1 family on its Google provider page as text-to-video and image-to-video models: veo-3.1-t2v, veo-3.1-fast-t2v, veo-3.1-lite-t2v, plus -i2v twins. Each model page quotes per-second pricing; re-pulled September 8, 2026 from the Veo 3.1 text-to-video model page (and its Fast and Lite siblings):

Route (per second) 720p 1080p 4K
Google Gemini API — Standard $0.40 $0.40 $0.60
Modellix veo-3.1-t2v — Standard $0.36 $0.36 $0.54
Google Gemini API — Fast $0.10 $0.12 $0.30
Modellix veo-3.1-fast-t2v — Fast $0.09 $0.108 $0.27
Google Gemini API — Lite $0.05 $0.08 —
Modellix veo-3.1-lite-t2v — Lite $0.045 $0.072 —

On the day we checked, Modellix’s list prices ran about 10% under the matching Gemini API tier and resolution — that is a snapshot, not a standing claim, so re-verify both pages before you commit a budget. Calling through Modellix follows the standard async pattern its documentation describes: one API key, submit the generation to the model’s task route, then poll until the video is ready — the Modellix API documentation and each model page carry the exact route and schema. The model pages also document Modellix’s own parameter surface for Veo 3.1 (prompt, negativePrompt, aspectRatio, duration, personGeneration, resolution), which mirrors Google’s with the addition of a negative prompt field.

When the direct route is still the right call: you need Google’s GA model and enterprise terms (provisioned throughput, fixed quota, CMEK/VPC-SC controls on the Enterprise Agent Platform); your workload has data-residency or regional constraints that rule out a middle layer; or Veo is core enough to your product that you want zero dependency on an intermediary. Direct access also gets new model IDs first — preview and GA launches land on Google’s API before any reseller. When Veo is one of ten models in a media pipeline rather than the whole product, the gateway is the point; our unified AI API explainer covers that architecture in depth.

Veo 3.1 on the Modellix REST API

See the live async task routes, model IDs, and per-call pricing for the Veo 3.1 family behind one Modellix key.

View Docs

Errors, rate limits, and preview caveats

The failures that burn the most time on a first Veo integration are not model errors:

  • 401 Unauthorized — wrong key, or the key’s project has no billing attached. The billing check is the one that dresses up as an auth error.
  • 404 on the model ID — you sent an old or alias ID. veo-3.0-* and veo-2.0-* shut down June 30, 2026; veo-3.1-quality-style aliases are not Gemini API IDs. Send the exact veo-3.1-*-generate-preview string.
  • 429 / quota errors — preview models carry rate limits and quotas that change; Google’s console and rate-limit pages document current numbers.
  • Audio blocking — Veo 3.1 sometimes refuses a generation because of safety filters on the audio track. Google’s docs state you are not charged for a blocked video.
  • Two-day retention — generated videos live on Google’s servers for 2 days, then are deleted. Download within that window or you regenerate.
  • Preview instability — “preview” is a promise to change: IDs get replaced at GA, behavior shifts, and Google announces deprecation per model. Read the deprecations page before you build and after every Google announcement.
  • Region-dependent parameters — in EU, UK, CH, and MENA locations, allow_adult is the only permitted personGeneration value; availability itself varies by region on Google’s available-regions page.
  • SynthID watermarking — all Veo output carries Google’s SynthID watermark, which matters if your pipeline redistributes clips.

Which route and tier should a new integration pick?

Three questions decide the route. One vendor or many? Veo-only and Google-centric → direct Gemini API. Multi-vendor media pipeline → aggregator. Who is the customer? Enterprise buyers needing fixed quota and compliance controls → the Enterprise Agent Platform GA model, not the preview API. How much do you trust a middle layer? Core-model dependency → direct; one-of-ten models → the gateway is the point. Then pick the tier the same way you pick any cloud SKU: prototype and iterate on Lite ($0.05/s at 720p) or Fast ($0.10/s at 720p), render hero output on Standard when 4K or reference-image consistency earns its $0.40–0.60/s. The one thing every route shares: prices and model status are moving targets while Veo 3.1 is in preview — pin the date when you record a number, and re-check both the pricing and deprecations pages before you scale.

Start Generating with Veo 3.1

Log in to Modellix to call Veo 3.1 and 210+ other image, video, and audio models through one API key.

Login

Frequently Asked Questions

Is the Veo 3.1 API free?

No. Veo 3.1 is a paid preview with no free tier on any tier — Google’s pricing page lists the free tier as “Not available” for Standard, Fast, and Lite. You pay per second of generated video, and the key’s Cloud project must have billing enabled.

How much does an 8-second Veo 3.1 clip cost?

Per second with audio: Standard $0.40 (720p/1080p) or $0.60 (4K), Fast $0.10/$0.12/$0.30, Lite $0.05/$0.08. An 8-second clip therefore runs from about $0.40 (Lite 720p) to $4.80 (Standard 4K) — September 8, 2026 figures from Google’s pricing page.

Can I call Veo 3.1 with Python?

Yes — the google-genai SDK’s client.models.generate_videos() wraps the whole submit-poll-download lifecycle; this guide’s Python example runs as-is once GEMINI_API_KEY is set. JavaScript, Go, and Java SDKs expose the same operation pattern, and REST works with plain curl plus jq.

Does the Veo 3.1 API support 4K?

Standard and Fast generate up to 4K (at the 8-second duration); Lite is capped at 1080p. On Modellix’s listing the same ceiling applies — 4K is priced on the standard and fast model pages only.

What is the difference between the Veo 3.1 API and the Veo 3 API?

Veo 3 (veo-3.0-generate-001 and veo-3.0-fast-generate-001) and Veo 2 were shut down on the Gemini API on June 30, 2026. Tutorials and reseller pages still teaching veo-3.0-* model IDs are describing dead endpoints; the current API surface is the three veo-3.1-*-generate-preview IDs.

Image-to-video, frame control, and extension — separate APIs?

No — all four are inputs to the same model endpoint. You pass a starting image, an optional lastFrame, up to three referenceImages (Standard/Fast only), or a prior video for extension into the same predictLongRunning call or generate_videos SDK call.

Google Veo model status and pricing reflect public information as of September 8, 2026 and change frequently — the pricing and deprecations pages were both updated within days of this snapshot, preview model IDs and aggregator listings shift without notice, and audio is always on (Google publishes no separate no-audio rate). Validate against Google’s pricing and deprecations pages and the specific provider’s live model page before committing budget. This article was written by Modellix, an API aggregator with a commercial interest in the single-key route it describes; the official Google integration material above is vendor-neutral, and the Modellix prices quoted are a same-day snapshot rather than a standing claim. Access 210+ image, video, and audio models through one API key at modellix.ai.