Veo 3.1 Fast Official Text-to-Video API

google/veo3.1-fast/text-to-video

Veo 3.1 Fast Official is engineered for high-frequency commercial production: rapid turnaround without sacrificing high-fidelity materials, multi-axis camera motion, or action-aligned native audio. With 720p / 1080p / 4K and transparent per-second pricing, it is the workhorse engine for daily volume pipelines.

Input

Prompt

325/1000

Duration

Aspect ratio

Resolution

Sound

Output

Idle

Your generated video will appear here

Add your prompt and required media, review the settings, then click Run.

Continue with

Veo 3.1 Official Text-to-Video Veo 3.1 Official Image-to-Video Veo 3.1 Fast Official Image-to-Video Veo 3.1 Lite Official Text-to-Video Veo 3.1 Lite Official Image-to-Video

Examples

A traceur sprints across city rooftops at golden hour and vaults a low vent, dynamic follow camera swinging with the stride, long shadows raking across gravel and antennas. Natural sound: rhythmic footsteps, a soft scuff on the vault, wind between buildings, distant traffic hum. Realistic athletic motion, no text, no logos.

An off-road motorbike crests a sand dune and powers down the slope, low tracking camera at wheel height, a rooster tail of sand catching late-afternoon light. Natural sound: engine rev rising then falling, sand hissing against the tires. Realistic motion, no text, no logos.

Slow push-in toward a timber cabin window glowing warm at blue-hour dawn, snow drifting past the frame, chimney smoke rising into a pale pink sky, pine branches heavy with fresh snow swaying gently. Quiet, calm, realistic winter atmosphere, no text, no logos.

REST API

Quick Start

Authenticate with the API, submit the inputs and instructions, then retrieve the video using the task ID.

Connect to the Vidgo API

Create an API key, keep it only on your server, and send Authorization: Bearer VIDGO_API_KEY.

Endpoint: POSThttps://api.vidgo.ai/api/generate/submit
Authentication: Authorization: Bearer VIDGO_API_KEY

Submit one generation task

Fill in the inputs and settings for this endpoint using the request example, then save the returned task_id to query generation progress and results.

Submit request

REQUEST_BODY=$(cat <<'JSON'
{
  "model": "google/veo3.1-fast/text-to-video",
  "input": {
    "prompt": "A traceur sprints across city rooftops at golden hour and vaults a low vent, dynamic follow camera swinging with the stride, long shadows raking across gravel and antennas. Natural sound: rhythmic footsteps, a soft scuff on the vault, wind between buildings, distant traffic hum. Realistic athletic motion, no text, no logos.",
    "duration": 8,
    "aspect_ratio": "16:9",
    "sound": true,
    "resolution": "720p"
  }
}
JSON
)

RESPONSE=$(curl --silent --show-error --fail-with-body \
  --request POST \
  --url "https://api.vidgo.ai/api/generate/submit" \
  --header "Authorization: Bearer $VIDGO_API_KEY" \
  --header "Content-Type: application/json" \
  --data "$REQUEST_BODY")

CODE=$(printf '%s' "$RESPONSE" | jq -r '.code // empty')
if [ "$CODE" != "0" ] && [ "$CODE" != "200" ]; then
  printf 'API error: %s
' "$RESPONSE" >&2
  exit 1
fi
printf '%s
' "$RESPONSE"

Wait for the result

Query with task_id, continue for not_started/running, and stop for finished/failed. On success, read data.files[].file_url.

Track status

GET https://api.vidgo.ai/api/generate/status/{task_id}

Poll status with a 2-second base interval, and increase the interval for longer tasks. Continue only while status is not_started or running, and stop once finished or failed. You can also specify callback_url in the request payload to receive webhook notifications.

not_startedrunningfinishedfailed

Submit response

{
  "code": 200,
  "data": {
    "task_id": "task-unified-...",
    "status": "running",
    "created_time": "2026-09-17T10:00:00Z"
  }
}

Finished response

{
  "code": 200,
  "data": {
    "task_id": "task-unified-...",
    "status": "finished",
    "files": [
      {
        "file_url": "https://storage.vidgo.ai/generated/video.mp4",
        "file_type": "video"
      }
    ],
    "created_time": "2026-08-22T10:00:00Z",
    "progress": 100,
    "error_message": null
  }
}

Complete runnable example

Expand for a complete script with HTTP and business-code checks, task_id validation, polling, terminal-state handling, and a timeout boundary.

Complete runnable example

set -euo pipefail
: "${VIDGO_API_KEY:?Set VIDGO_API_KEY in your environment}"

REQUEST_BODY=$(cat <<'JSON'
{
  "model": "google/veo3.1-fast/text-to-video",
  "input": {
    "prompt": "A traceur sprints across city rooftops at golden hour and vaults a low vent, dynamic follow camera swinging with the stride, long shadows raking across gravel and antennas. Natural sound: rhythmic footsteps, a soft scuff on the vault, wind between buildings, distant traffic hum. Realistic athletic motion, no text, no logos.",
    "duration": 8,
    "aspect_ratio": "16:9",
    "sound": true,
    "resolution": "720p"
  }
}
JSON
)

SUBMIT_RESPONSE=$(curl --silent --show-error --fail-with-body \
  --request POST \
  --url "https://api.vidgo.ai/api/generate/submit" \
  --header "Authorization: Bearer $VIDGO_API_KEY" \
  --header "Content-Type: application/json" \
  --data "$REQUEST_BODY")

TASK_ID=$(printf '%s' "$SUBMIT_RESPONSE" | jq -r '.data.task_id // .task_id // empty')
BUSINESS_CODE=$(printf '%s' "$SUBMIT_RESPONSE" | jq -r '.code // empty')
if [ "$BUSINESS_CODE" != "0" ] && [ "$BUSINESS_CODE" != "200" ]; then
  printf 'Submit failed:
%s
' "$SUBMIT_RESPONSE" >&2
  exit 1
fi
if [ -z "$TASK_ID" ]; then
  printf 'Submit response did not include task_id:
%s
' "$SUBMIT_RESPONSE" >&2
  exit 1
fi

START_TIME=$(date +%s)
POLL_DELAY=2
while true; do
  if [ $(( $(date +%s) - START_TIME )) -ge 600 ]; then
    printf 'Timed out after 600 seconds
' >&2
    exit 1
  fi
  STATUS_RESPONSE=$(curl --silent --show-error --fail-with-body \
    --url "https://api.vidgo.ai/api/generate/status/$TASK_ID" \
    --header "Authorization: Bearer $VIDGO_API_KEY")
  STATUS=$(printf '%s' "$STATUS_RESPONSE" | jq -r '.data.status // .status // empty')
  BUSINESS_CODE=$(printf '%s' "$STATUS_RESPONSE" | jq -r '.code // empty')
  if [ "$BUSINESS_CODE" != "0" ] && [ "$BUSINESS_CODE" != "200" ]; then
    printf 'Status request failed:
%s
' "$STATUS_RESPONSE" >&2
    exit 1
  fi

  case "$STATUS" in
    finished)
      printf '%s' "$STATUS_RESPONSE" | jq -r '(.data.files // .files // [])[]?.file_url'
      break
      ;;
    failed)
      printf '%s' "$STATUS_RESPONSE" | jq -r '.data.error_message // .error_message // "Generation failed"' >&2
      exit 1
      ;;
    not_started|running)
      sleep "$POLL_DELAY"
      if [ "$POLL_DELAY" -lt 10 ]; then POLL_DELAY=$((POLL_DELAY + 1)); fi
      ;;
    *)
      printf 'Unexpected task status: %s
' "$STATUS" >&2
      exit 1
      ;;
  esac
done

Input parameters

The table lists available input parameters, types, and defaults. Request examples also include the required top-level model field. Prepare the inputs for this task and configure the output.

Field	Type	Required	Default	Description
prompt	string	Yes	—	1–1,000 characters after trimming.
duration	integer	No	8	4, 6, or 8, in seconds.
aspect_ratio	string	No	16:9	16:9 or 9:16.
resolution	string	No	720p	720p / 1080p / 4k.
sound	boolean	No	true	true generates native audio; false returns a silent clip.

Response Fields

A successful submission returns a task ID. Status queries provide progress, output files, and error details when a task fails.

Field	Type	Description
code	integer	Application result code; successful responses use 0 or 200.
message	string	Human-readable message or error detail when present.
data.task_id	string	Task ID used in the status endpoint path.
data.status	string	not_started, running, finished, or failed.
data.created_time	string	Task creation time in date-time format.
data.progress	integer	Task progress from 0 to 100, when included in the response.
data.files[]	array	All output files from a successful task, in response order.
data.files[].file_url	string	Public URL for a generated video.
data.files[].file_type	string	File type, such as video.
data.error_message	string \| null	Failure detail when status is failed.

Task Lifecycle

Continue querying while the status is not_started or running. End polling at finished or failed, then process the output files or error details respectively.

not_started
The task was accepted and is waiting to begin.
running
Generation is in progress. Continue polling the same task_id.
finished
Generation succeeded. Read every video URL from data.files[].file_url.
failed
Generation stopped with an error. Read data.error_message and stop polling.

Polling and Errors

AuthenticationFor a 401 response, check the Bearer API key in Authorization, update the credentials, and retry.
ValidationFor a 400 response, use the response details to check required inputs, parameter values, and available credits, then make the indicated adjustments before submitting again.
Network and timeoutIf a status query encounters a network error or timeout, retain the original task_id and retry the query, then handle the result according to the returned task status.
Polling intervalPoll status with a 2-second base interval, and gradually increase the interval for longer tasks.
Terminal statesContinue only for not_started or running. Stop immediately on finished or failed.
Callback optionProvide callback_url at the request top level to receive the final flat task object; polling remains available if delivery fails.

Endpoint limits

Specification	Value	Details
Input mode	Text only	A prompt defines the scene, camera, lighting, mood, and sound.
Output	Video with optional native audio	The endpoint returns an asynchronous task ID; finished tasks include a video file.
Resolution	720p / 1080p / 4k	Default is 720p.
Duration	4 / 6 / 8 seconds	Default is 8 seconds.
Aspect ratio	16:9 / 9:16	Default is 16:9.
Billing basis	Per second	720p silent 10 credits/s; audio 15 credits/s. 1080p silent 10 credits/s; audio 15 credits/s. 4k silent 30 credits/s; audio 35 credits/s.

View Veo 3.1 Fast Official Text-to-Video API documentation

Veo 3.1 Fast Official Text-to-Video

Google's Veo 3.1 Fast Official text-to-video endpoint strikes the golden balance between generation speed and visual fidelity. Orchestrate subject motion, camera trajectories, lighting, and ambient sound through text to deliver 4–8 second production-ready clips—ideal for ad iteration, social batch output, and mid-to-high throughput pipelines.

Why Choose This?

Golden Balance of Speed and FidelityThe Fast architecture carefully balances turnaround speed with visual detail—preserving nuanced material reflections and natural lighting while sustaining high-frequency delivery cadence.
Multi-Axis Camera ControlDirect push-ins, tracking shots, orbits, and low-angle sweeps with stable trajectories that quickly serve story focus and product storytelling.
Synchronized Native AudioGenerates action-matched ambience, mechanical Foley, and atmospheric sound in a single pass—reducing post-production audio stitching even in batch workflows.
Full Resolution Ladder to 4KOutput at 720p, 1080p, or 4K. Iterate quickly in HD, then elevate selected shots to ultra HD for final delivery.
Workhorse for High-Frequency ProductionBuilt for ad variants, social shorts, and platform-scale pipelines where throughput and audiovisual completeness must coexist.
Flexible Per-Second PricingIndependently toggle native audio and choose exact 4, 6, or 8 second durations so batch costs stay transparent and controllable.

Parameters

Parameter	Requirement	Description
prompt	Required	String. Directs the scene, action, camera, lighting, and sound; 1–1,000 characters after trimming.
duration	Optional	Integer. Sets output length; the Playground preselects 8 seconds. Default`846`
aspect_ratio	Optional	String. Controls output framing; the Playground preselects 16:9. Default`16:99:16`
resolution	Optional	String. Sets output resolution; the Playground preselects 720p. Default`720p1080p4k`
sound	Optional	Boolean. Enables native audio; the Playground defaults to true. Default`truefalse`

How to Use

Define Subject and Dynamic ActionSpecify the main subject and its kinetic progression, e.g., 'A coral-red delivery robot glides forward from the curb into a rain-glossed crosswalk.'
Direct Camera and AtmosphereAdd precise camera movement and lighting notes, e.g., 'Low tracking camera at wheel height, warm sunset reflections sliding across panels, subtle city ambience.'
Configure Duration and AudioSelect 4, 6, or 8 seconds, and toggle native audio (sound: true) to generate synchronized Foley and ambient soundscapes.
Set Resolution and Aspect RatioChoose 16:9 horizontal or 9:16 vertical framing. Use 720p/1080p for daily volume, then switch to 4K for final delivery.
Confirm Pricing and RunReview the exact per-second credit estimate, click Run, and preview or download the finished video once complete.

Pricing

Veo 3.1 Fast Official is billed by generated seconds. Final cost = duration x selected per-second rate. USD equivalents use the current base API billing rate of 2,000 credits for $10. Example: an 8-second Fast 720p audio job uses 8 x 15 = 120 credits, about $0.6 at the base API credit rate.

Usage	Rate	Details
720p, no audio	10 credits/sec ($0.05/sec)	8 seconds = 80 credits ($0.4).
720p, audio	15 credits/sec ($0.075/sec)	Default 720p / 8s audio costs 120 credits ($0.6).
1080p, no audio	10 credits/sec ($0.05/sec)	8 seconds = 80 credits ($0.4).
1080p, audio	15 credits/sec ($0.075/sec)	8 seconds = 120 credits ($0.6).
4k, no audio	30 credits/sec ($0.15/sec)	8 seconds = 240 credits ($1.20).
4k, audio	35 credits/sec ($0.175/sec)	8 seconds = 280 credits ($1.40).

Best Use Cases

Ad Variants & Campaign Batch OutputRapidly generate multi-cut product shots, promo openers, and channel-adapted variants under a unified visual language to sustain high-frequency launch cadence.
Industrialized Social ShortsCombine 9:16 vertical framing with native audio to efficiently produce scroll-stopping brand clips, unboxings, and seed content.
Mid-to-High Throughput Content PipelinesServe as the daily production workhorse—balancing speed, fidelity, and 4K upgrade headroom for creator tools and media platforms.
Fast Finalization After Storyboard LockOnce Lite has locked framing and motion, switch to Fast to render audio-enabled HD/4K deliverables and shorten the path from review to ship.

Pro Tips

Structured Prompt Formula: Organize prompts into 'Subject Details + Action Progression + Camera Motion + Lighting/Texture + Sound Design' to maximize semantic density within 1,000 characters.
Decouple Subject and Camera Motion: Describe subject movement and camera paths in distinct clauses (e.g., 'The runner accelerates across the bridge; the camera keeps pace in a low tracking shot') to avoid conflicting trajectories.
Highlight Physical and Material Interactions: Mention specific dynamics like splashing puddles or billowing fabric so Fast can leverage Veo 3.1's world-model strengths.
Cue Native Audio with Specific Soundscapes: Anchor sound cues to visible sources, e.g., 'Audio: low hum of electric motor and wet tire tread sounds,' for precise audiovisual sync.
Adopt a Tiered Production Pipeline: Prototype with Lite (720p, no audio) to lock framing, then switch to Fast 1080p or 4K with audio for volume delivery.

Usage notes

Veo 3.1 Fast Official Text-to-Video generates video from a required text prompt, with duration, resolution, aspect ratio, and sound settings to configure the output.
Prompts are limited to 1,000 characters. Duration supports 4, 6, or 8 seconds.
Use the sound parameter to request audio or silent output. Audio and no-audio jobs have different per-second rates.
Fast and Quality Official support 720p, 1080p, and 4K.
This endpoint is text-only. Use the Official Image-to-Video pages for start-frame or first/last-frame jobs.
Save the task_id returned by an API submission to query progress and retrieve the result.

Veo 3.1 Official Image-to-VideoAnimate a start image with optional native audio, and add an optional end frame to guide the closing shot.

Veo 3.1 Fast Official Image-to-VideoAnimate a start image with optional native audio, and add an optional end frame to guide the closing shot.

Veo 3.1 Lite Official Text-to-VideoGenerate a 4, 6, or 8 second clip with optional native audio from a text prompt.

Veo 3.1 Lite Official Image-to-VideoAnimate a start image with optional native audio, and add an optional end frame to guide the closing shot.

Veo 3.1 Fast Official Text-to-Video API frequently asked questions

What is the Veo 3.1 Fast Official Text-to-Video API?

Veo 3.1 Fast Official is the balanced tier of Google's Veo 3.1 family built for high-frequency production. This endpoint turns text prompts into 4–8 second videos with authentic physics, cinematic camera control, and synchronized native audio up to 4K—ideal as a daily commercial workhorse via Vidgo API or the online playground.

What model ID should I use in API requests?

Specify google/veo3.1-fast/text-to-video in the model field. For Quality or Lite, use google/veo3.1/text-to-video and google/veo3.1-lite/text-to-video respectively. Do not submit URL paths containing -official.

How does native audio generation work on Fast?

Veo 3.1 features native audiovisual co-generation. By setting sound: true and including sound descriptors in your prompt, the model embeds synchronized Foley, atmospheric soundscapes, and mechanical audio directly into the output MP4—especially valuable for shortening post work in batch pipelines.

Which resolutions does Fast support, and when should I use 4K?

Fast supports 720p, 1080p, and 4K. Use 720p/1080p for daily iteration and social volume; switch to 4K when shots need large-format display, brand hero assets, or high-resolution final delivery that preserves textures and lighting detail.

How do I direct camera motion through prompt engineering?

Use dedicated cinematic phrasing in distinct clauses, such as 'slow push-in', 'low tracking camera at wheel height', or '360-degree orbit around the subject'. Fast reliably executes standard cinematography terminology when shot size changes and move rates are also specified.

When should I choose Fast instead of Lite or Quality?

Choose Lite for high-volume, low-cost prompt exploration; choose Quality for flagship cinematic fidelity and premium finals; choose Fast when you need the golden balance of speed, high-fidelity visuals, and 4K capability for high-frequency commercial production.

What are the benefits of per-second pricing for volume production?

Per-second billing keeps batch costs granular and transparent. Pay only for the exact 4s, 6s, or 8s you need, disable audio during previews to reduce spend, then enable audio and higher resolution once creative direction is locked.

Does this text-to-video endpoint support image inputs?

This text-to-video endpoint is dedicated to text prompts. To animate a single starting image or interpolate between start and end frames, use the Veo 3.1 Fast Official Image-to-Video endpoint.