Skip to content
Dashboard

Veo 3.1 Fast Generate

Veo 3.1 Fast Generate is the speed-optimized Veo 3.1 model, bringing the 3.1 generation's improvements to a lower-latency serving configuration, designed for rapid prompt iteration, parallel generation batches, and high-frequency creative workflows where each generation feeds the next.

View API reference
Price
$0.10, Per second
Lowest available configuration
import { experimental_generateVideo as generateVideo } from 'ai';
const result = await generateVideo({
model: 'google/veo-3.1-fast-generate-001',
prompt: 'A serene mountain lake at sunrise.'
});
Read docs

Copy link to headingPlayground

Try out Veo 3.1 Fast Generate by Google. Usage is billed to your team at API rates. Free users (those who haven't made a payment) get $5 of credits every 30 days.

google logo
Images(optional)
Add up to 3 images
Videos(optional)
Prompt(optional)

End frame(optional)
Duration8s
4s8s
Resolution
Aspect ratio
Videos to generate
google logo

Your generated video will appear here.

Copy link to headingProviders

Route requests across multiple providers. Copy a provider slug to set your preference. Visit the docs for more info. Using a provider means you agree to their terms, listed under Legal.

Provider
Input
Output
Capabilities
ZDR
No Training
Free Tier
Release Date
$0.10/sec+2 more
10/15/2025

Getting started

Generate videos with Veo 3.1 Fast Generate using the experimental_generateVideo function from AI SDK 6 or later. AI Gateway handles routing and polls until the video is ready.

Install the AI SDK (pnpm add ai dotenv), create an API key from the API Keys page, and set it as AI_GATEWAY_API_KEY in your environment. Full setup is covered in the video generation quickstart.

index.ts
import { experimental_generateVideo as generateVideo } from 'ai';
import fs from 'node:fs';
import 'dotenv/config';
async function main() {
const result = await generateVideo({
model: 'google/veo-3.1-fast-generate-001',
prompt:
'A pangolin curled on a mossy stone in a glowing bioluminescent forest',
generateAudio: true,
});
// Save the generated video
fs.writeFileSync('output.mp4', result.videos[0].uint8Array);
console.log('Video saved to output.mp4');
}
main().catch(console.error);

Top-level parameters

Load the supported top-level parameters: prompt, aspectRatio, duration, resolution, and generateAudio.

top-level-params.ts
import { experimental_generateVideo as generateVideo } from 'ai';
import fs from 'node:fs';
import 'dotenv/config';
async function main() {
const result = await generateVideo({
model: 'google/veo-3.1-fast-generate-001',
prompt:
'A pangolin curled on a mossy stone in a glowing bioluminescent forest',
aspectRatio: '16:9',
duration: 8,
resolution: '1080p',
generateAudio: true,
});
// Save the generated video
fs.writeFileSync('output.mp4', result.videos[0].uint8Array);
console.log('Video saved to output.mp4');
}
main().catch(console.error);
ParameterTypeRequiredDescription
promptstringNoText description of the video to generate.
duration4 | 6 | 8NoVideo length in seconds. 4 or 6 or 8 seconds.
resolutionstringNoResolution ('1280x720', '1920x1080', '3840x2160').
aspectRatiostringNoAspect ratio ('16:9', '9:16').
generateAudiobooleanNoGenerate synchronized audio with the video.
frameImagesArray<{ image: string; frameType: 'first_frame' | 'last_frame' }>NoFirst and last frames of the clip. A first_frame entry replaces prompt.image and wins when both are set, and adding a last_frame makes Veo animate from the first frame toward the last.
inputReferencesArray<string>NoReference images that guide the assets and style of the scene you describe in the prompt. They are not used as the first frame, and there is no prompt syntax for addressing them individually. Images only.

Input limits

InputFormatsSourcesMax countMax sizeLimits
Imagejpg, jpeg, pngurl, base64320 MB
Videomp4url1

Provider options

Pass Veo-specific options under providerOptions.vertex. This call loads every text-to-video option that combines in a single request. resizeMode is image-to-video only (see below), while referenceImages and gcsOutputDirectory change the inputs/output destination and are omitted here.

provider-options.ts
import { experimental_generateVideo as generateVideo } from 'ai';
import fs from 'node:fs';
import 'dotenv/config';
async function main() {
const result = await generateVideo({
model: 'google/veo-3.1-fast-generate-001',
prompt:
'A pangolin curled on a mossy stone in a glowing bioluminescent forest',
generateAudio: true,
providerOptions: {
vertex: {
enhancePrompt: true,
negativePrompt: 'blurry, low quality, distorted',
personGeneration: 'allow_adult',
compressionQuality: 'optimized',
sampleCount: 1,
seed: 42,
pollIntervalMs: 5000,
pollTimeoutMs: 600000,
},
},
});
// Save the generated video
fs.writeFileSync('output.mp4', result.videos[0].uint8Array);
console.log('Video saved to output.mp4');
}
main().catch(console.error);

Pass Veo-specific options under providerOptions.vertex in your generateVideo call.

ParameterTypeRequiredDescription
enhancePromptbooleanNoUse Gemini to enhance prompts. Defaults to true.
negativePromptstringNoWhat to discourage in the generated video.
personGeneration'dont_allow' | 'allow_adult' | 'allow_all'NoWhether to allow person generation. Defaults to 'allow_adult'.
compressionQuality'optimized' | 'lossless'NoCompression quality. Defaults to 'optimized'.
sampleCountnumberNoNumber of output videos (1-4).
seednumberNoSeed for deterministic generation (0-4,294,967,295).
gcsOutputDirectorystringNoCloud Storage URI to store the generated videos.
referenceImagesarrayNoReference images for style or asset guidance. Legacy alternative to the top-level inputReferences, used only when inputReferences is omitted.
resizeMode'pad' | 'crop'NoImage-to-video only: how to resize the input image to fit video dimensions. Defaults to 'pad'.
pollIntervalMsnumberNoHow often to check task status. Defaults to 5000.
pollTimeoutMsnumberNoMaximum wait time. Defaults to 600000 (10 minutes).

Duration and resolution

1080p and 4K require duration: 8. At 720p, you can use 4, 6, or 8 seconds.

Frames take priority over references

Frames and references are mutually exclusive. When frameImages is set, inputReferences and the legacy providerOptions.vertex.referenceImages are ignored.

The top-level parameters win over their provider-option equivalents: frameImages overrides prompt.image, and inputReferences overrides providerOptions.vertex.referenceImages.

Image to video

Animate a starting image by passing prompt as an object with image and an optional text field.

image-to-video.ts
import { experimental_generateVideo as generateVideo } from 'ai';
import fs from 'node:fs';
import 'dotenv/config';
async function main() {
const result = await generateVideo({
model: 'google/veo-3.1-fast-generate-001',
prompt: {
image: 'https://example.com/landscape.png',
text: 'Camera slowly pans across the scene as clouds drift by',
},
duration: 8,
resolution: '1080p',
generateAudio: true,
providerOptions: {
vertex: {
resizeMode: 'crop',
},
},
});
// Save the generated video
fs.writeFileSync('output.mp4', result.videos[0].uint8Array);
console.log('Video saved to output.mp4');
}
main().catch(console.error);

First and last frame

Transition between a starting and ending image. Pass both frames through the top-level frameImages, tagging one first_frame and one last_frame. Veo animates from the first frame toward the last.

veo-first-last-frame.ts
import { experimental_generateVideo as generateVideo } from 'ai';
import fs from 'node:fs';
import 'dotenv/config';
async function main() {
const result = await generateVideo({
model: 'google/veo-3.1-fast-generate-001',
prompt: '360 pan from the first frame to the last frame',
frameImages: [
{ image: 'https://example.com/start.png', frameType: 'first_frame' },
{ image: 'https://example.com/end.png', frameType: 'last_frame' },
],
aspectRatio: '16:9',
resolution: '720p',
duration: 8,
});
// Save the generated video
fs.writeFileSync('output.mp4', result.videos[0].uint8Array);
console.log('Video saved to output.mp4');
}
main().catch(console.error);

Reference to video

Guide the assets and style of a generated scene with reference images passed through the top-level inputReferences. The references are not used as the first frame, and Veo has no prompt syntax for addressing them individually — describe how they should appear in the scene instead.

veo-reference-to-video.ts
import { experimental_generateVideo as generateVideo } from 'ai';
import fs from 'node:fs';
import 'dotenv/config';
async function main() {
const result = await generateVideo({
model: 'google/veo-3.1-fast-generate-001',
prompt:
'The video opens with a medium shot of a woman in a high-fashion flamingo dress walking through a lagoon',
inputReferences: [
'https://example.com/dress.png',
'https://example.com/glasses.png',
'https://example.com/woman.png',
],
aspectRatio: '16:9',
duration: 8,
generateAudio: true,
});
// Save the generated video
fs.writeFileSync('output.mp4', result.videos[0].uint8Array);
console.log('Video saved to output.mp4');
}
main().catch(console.error);

Copy link to headingMore models by Google

Model
Context
Latency
Throughput
Input
Output
Cache
Web Search
Capabilities
Providers
ZDR
No Training
Free Tier
Release Date
1M1.9 s417 tps
$0.75/M
$3.75/M
Read$0.08/M
$14/K+1 more
+3
google logo
vertex logo
09/02/2026
1M0.9 s279 tps
$0.75/M
$3.75/M
Read$0.08/M
$14/K+1 more
+3
google logo
vertex logo
08/13/2026
1M0.5 s307 tps
$0.30/M
$2.50/M
Read$0.03/M
$14/K+1 more
+3
google logo
vertex logo
07/21/2026
1M0.6 s255 tps
$0.25/M
$1.50/M
Read$0.03/M
$14/K+1 more
+3
google logo
vertex logo
05/07/2026
1M0.6 s199 tps
$0.50/M+1 more
$3/M+1 more
Read$0.05/M
$14/K+1 more
+3
google logo
vertex logo
12/17/2025
1M0.3 s271 tps
$0.10/M
$0.40/M
Read$0.01/M
$35/K+1 more
+3
google logo
vertex logo
06/17/2025

Copy link to headingAbout Veo 3.1 Fast Generate

Veo 3.1 Fast Generate is the fast-tier configuration of the Veo 3.1 generation. It shares the same architecture as Veo 3.1 Generate but trades some generation compute for faster response times. This makes it the logical choice for exploratory and iterative phases of video production: generating multiple prompt variations, testing scene descriptions before committing to full-quality renders, and running batch jobs where throughput matters.

The Veo 3.1 generation brings improvements over 3.0 in motion quality and prompt adherence. Veo 3.1 Fast Generate carries those improvements into the fast tier. Teams upgrading from Veo 3.0 Fast get better generation quality at similar or improved latency. For new projects starting on Veo 3.1, this is the recommended fast-tier entry point over Veo 3.0 Fast.

Parallel generation workflows benefit particularly from the reduced per-generation latency. A batch of 10 prompt variations completes faster, and the quicker turnaround supports tighter feedback loops between creative direction and generation output.

Copy link to headingWhat To Consider When Choosing a Provider

  • Configuration: For high-frequency batch generation, confirm provider rate limits before routing production load to ensure generation jobs do not queue unexpectedly.
  • Zero Data Retention: Zero Data Retention is available for this model. It is offered on a per-provider and model basis. See the documentation for details.
  • Authentication: AI Gateway authenticates requests using an API key or OIDC token. You do not need to manage provider credentials directly.

Copy link to headingWhen to Use Veo 3.1 Fast Generate

Best for

  • Prompt iteration and A/B testing at scale: Generate multiple variations of a scene description quickly, evaluate which direction works, then use Veo 3.1 Generate for the final render of the selected approach
  • Parallel batch generation: Running many concurrent generation jobs (advertising variants, scene options, visual development exploration) benefits from the lower per-job latency and faster batch completion
  • New projects on the Veo 3.1 generation: For teams starting fresh, Veo 3.1 Fast Generate is the recommended fast-tier entry point; it carries 3.1's generation improvements over choosing Veo 3.0 Fast instead
  • High-frequency creative pipelines: Workflows where video is generated and reviewed continuously (content moderation testing, generative art pipelines, automated video production systems) benefit from the throughput of the fast tier

Consider alternatives when

  • Final production-quality output is the goal: Veo 3.1 Generate applies full generation compute to each request and is more appropriate for final deliverables than for exploratory generation
  • Existing workflows are tuned to Veo 3.0: If prompt tuning and output validation was done against Veo 3.0 Fast, migrating to 3.1 Fast should be validated before replacing production traffic
  • Maximum Veo 3.1 quality regardless of speed: Veo 3.1 Generate is the quality ceiling within the Veo 3.1 family

Veo 3.1 Fast Generate is the fast-tier entry point to the Veo 3.1 generation, carrying the generation improvements of 3.1 into a lower-latency configuration suited for iteration, batch generation, and high-frequency creative workflows. For new projects, it is the recommended fast-tier choice over Veo 3.0 Fast.

Copy link to headingFrequently Asked Questions

  • How does Veo 3.1 Fast Generate differ from Veo 3.0 Fast Generate?

    Veo 3.1 Fast Generate is the Veo 3.1 generation. The 3.1 generation brings motion quality and prompt adherence improvements over 3.0. For new projects in the fast tier, 3.1 Fast is the recommended choice over 3.0 Fast.

  • How does Veo 3.1 Fast Generate differ from Veo 3.1 Generate?

    Both are Veo 3.1 generation models. Fast Generate uses reduced generation compute for lower latency, appropriate for iteration and batch work. Standard Generate applies full compute for production-quality output.

  • What is the ideal workflow combining both Veo 3.1 variants?

    Use Veo 3.1 Fast Generate for prompt exploration and variation generation. Once a direction is validated, run the selected prompt through Veo 3.1 Generate for the final production-quality render.

  • Does Veo 3.1 Fast Generate support image-to-video generation?

    Yes, image-to-video is supported alongside text-to-video at the fast-tier latency profile.

  • What resolution and duration does Veo 3.1 Fast Generate support?

    Up to 1080p. Duration and aspect ratios depend on the provider; see the Specs table on this page for details.

  • How do I use Veo 3.1 Fast Generate on AI Gateway?

    Use the identifier google/veo-3.1-fast-generate-001 with the generateVideo interface. AI Gateway handles provider routing automatically.

Your use is subject to Google's Terms & Privacy Policies.