Veo 3.1 Fast Official Image-to-Video API

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

Veo 3.1 Fast Official brings still imagery to life with high-fidelity motion. Featuring start-frame animation and smooth first-to-last frame interpolation, it balances rapid turnaround with material and lighting consistency, synchronized native audio, and up to 4K output—the workhorse for e-commerce demos and brand visual volume.

Input

Prompt

305/1000

Start frame

Add start

Upload a start image first, then add an optional end frame to guide the closing shot.

End frame

Add end

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 Text-to-Video Veo 3.1 Lite Official Text-to-Video Veo 3.1 Lite Official Image-to-Video

Examples

A paper boat released into a clear forest stream drifts downstream toward the lip of a small mossy waterfall, the camera following at water level past smooth stones and ferns. Natural sound: babbling water growing louder near the falls, birdsong, a distant woodpecker. Realistic motion, no text, no logos.

The ginger cat on the sunny windowsill lifts its head, ears swiveling toward a sound off-camera, then looks directly into the lens as sunlight creeps across its fur. Natural sound: a soft meow, purring, muted street noise through the glass. Realistic motion, no text, no logos.

Time-lapse of a seedling rising from dark soil, unfurling leaves and opening a single white blossom, ending on the open flower with fine water droplets. Soft diffused light, clean macro focus, quiet studio stillness. Realistic botanical motion, 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/image-to-video",
  "input": {
    "prompt": "A paper boat released into a clear forest stream drifts downstream toward the lip of a small mossy waterfall, the camera following at water level past smooth stones and ferns. Natural sound: babbling water growing louder near the falls, birdsong, a distant woodpecker. Realistic motion, no text, no logos.",
    "duration": 8,
    "aspect_ratio": "16:9",
    "sound": true,
    "resolution": "720p",
    "image_urls": [
      "https://cdn.vidgo.ai/apis/models/google/veo-3.1-fast-official/image-to-video/v1/01/input-start-frame.png",
      "https://cdn.vidgo.ai/apis/models/google/veo-3.1-fast-official/image-to-video/v1/01/input-end-frame.png"
    ],
    "generation_type": "frame"
  }
}
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/image-to-video",
  "input": {
    "prompt": "A paper boat released into a clear forest stream drifts downstream toward the lip of a small mossy waterfall, the camera following at water level past smooth stones and ferns. Natural sound: babbling water growing louder near the falls, birdsong, a distant woodpecker. Realistic motion, no text, no logos.",
    "duration": 8,
    "aspect_ratio": "16:9",
    "sound": true,
    "resolution": "720p",
    "image_urls": [
      "https://cdn.vidgo.ai/apis/models/google/veo-3.1-fast-official/image-to-video/v1/01/input-start-frame.png",
      "https://cdn.vidgo.ai/apis/models/google/veo-3.1-fast-official/image-to-video/v1/01/input-end-frame.png"
    ],
    "generation_type": "frame"
  }
}
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.
image_urls	array	Yes	—	1 or 2 public image URLs. Two images also send generation_type as frame.
generation_type	string	No	frame with two images	Optional. Omitted with one image; defaults to frame with two images. Explicit frame requires exactly two images.
duration	integer	No	8	4, 6, or 8, in seconds.
aspect_ratio	string	No	16:9	auto, 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	Image plus text	A start image is required. An optional end image uses first/last-frame control.
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	auto / 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 Image-to-Video API documentation

Veo 3.1 Fast Official Image-to-Video

Google's Veo 3.1 Fast Official image-to-video endpoint is built for high-speed animation of visual assets. Begin with a single start frame or interpolate between two keyframes, directing camera trajectories and spatial sound via text to turn product photography and concept art into 4–8 second production-ready motion.

Why Choose This?

Start-Frame AnimationInherits composition, subject features, and lighting from your source image to initiate organic, fluid motion from frame one.
First/Last-Frame InterpolationSupply both opening and closing keyframes, allowing the model to bridge the narrative arc with physically plausible transitions.
High-Fidelity Subject ConsistencyPreserves facial likeness, product details, and specular lighting even at high generation speed—ideal for e-commerce and brand visual volume.
Synchronized Native AudioSynthesizes action-aligned Foley and environmental soundscapes from visual dynamics and text cues, cutting post-audio work in batch pipelines.
Full Resolution Ladder to 4KOutput at 720p, 1080p, or 4K. Iterate quickly in HD, then elevate selected assets to ultra HD for final delivery.
Flexible Per-Second PricingControl durations (4s, 6s, or 8s) and audio toggles down to the second, keeping costs clear from drafts through batch finals.

Parameters

Parameter	Requirement	Description
prompt	Required	String. Directs the scene, action, camera, lighting, and sound; 1–1,000 characters after trimming.
image_urls	Required	String array with one or two public URLs. The first image is the start frame; the optional second image is the end frame and sends generation_type as frame. JPEG, PNG, or WebP, up to 10 MB each.
generation_type	Optional	Optional. Omitted with one image; defaults to frame with two images. Explicit frame requires exactly two images.
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. auto is available for image-to-video. Default`16:9auto9: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

Upload a High-Resolution Start ImageChoose a clear, well-lit image (JPEG/PNG/WebP, up to 10MB) to ground the visual styling and opening composition.
Optionally Add an End FrameTo define an explicit narrative endpoint or pose transition, upload an optional last frame for seamless keyframe interpolation.
Direct Motion and Sound via PromptGuide the kinetic progression and camera path, e.g., 'The subject turns toward the floor-to-ceiling window as the camera tracks forward, accompanied by the gentle sound of rain.'
Configure Aspect Ratio, Duration & AudioSelect 'auto' to inherit the original aspect ratio or choose 16:9/9:16; set duration (4s, 6s, 8s) and toggle native audio. Use 720p/1080p for daily volume, 4K for finals.
Review Per-Second Estimate & RunCheck the credit calculation, click Run, and preview or download the finished video with synchronized sound.

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

High-Volume E-Commerce Product DemosBatch-convert studio product stills into turntable or macro lighting sweeps while preserving subject consistency for frequent catalog updates.
Dynamic Posters & Brand VisualsExtend static print posters into vertical audiovisual assets with rich soundscapes for high-converting social campaigns.
Rapid Concept Art AwakeningInject natural motion and cinematic depth into illustrations and character key art—ideal for multi-variant motion tests before review lock.
Keyframe Transition Batch PrototypingUse dual-frame control to quickly validate environmental shifts and pose transitions, then elevate to 1080p/4K with audio for commercial delivery.

Pro Tips

Respect Source Framing and Physics: Ground prompts in the established geometry, lighting, and depth of the starting frame rather than describing contradictory physics.
Prompting Keyframe Interpolation: When using both start and end frames, focus your prompt on 'how the transition occurs'—specifying subject choreography and camera drift.
Preserve Composition with 'auto' Aspect Ratio: Set aspect_ratio to 'auto' to automatically match your source image dimensions to guide output framing.
Anchor Audio to Visual Elements: Highlight sound cues inherent in the image, e.g., 'Audio: torrential rush of cascading waterfall and misty reverberations,' for heightened immersion.
Tiered Volume Pipeline: Rapidly test animation dynamics with Lite (720p, no audio), then elevate locked assets to Fast 1080p or 4K with audio for batch delivery.

Usage notes

Veo 3.1 Fast Official Image-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.
Image-to-video accepts one start image, or two images for first/last-frame control.
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 Text-to-VideoGenerate a 4, 6, or 8 second clip with optional native audio from a text prompt.

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 Image-to-Video API frequently asked questions

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

Veo 3.1 Fast Official Image-to-Video is the balanced image-driven tier of Google's Veo 3.1 family for high-frequency production. Animate a single still from frame one or interpolate between two images with precise first/last-frame control, featuring synchronized native audio and resolutions up to 4K—ideal for e-commerce demos and brand visual volume via Vidgo API or the playground.

What model ID should I use in API requests?

Set the model field to google/veo3.1-fast/image-to-video. For Quality or Lite, use google/veo3.1/image-to-video and google/veo3.1-lite/image-to-video respectively. Do not submit URLs containing -official.

How many images can I submit and what are the modes?

You can submit 1 or 2 images. Supplying 1 image activates start-frame animation where the clip initiates from the image. Supplying 2 images activates first/last-frame mode (automatically submitting generation_type: "frame"), guiding the model to generate a seamless transition between the two states.

Does Fast image-to-video support synchronized native audio?

Yes. By setting sound: true and adding sound notes in your prompt, the generated MP4 includes action-aligned Foley, mechanical sounds, and atmospheric audio—especially valuable for shortening post work in batch pipelines.

What are the advantages of using 'auto' aspect ratio?

Choosing 'auto' preserves your source image's native aspect ratio, preventing unwanted cropping, pillarboxing, or distortion. You can also explicitly specify 16:9 or 9:16 for targeted distribution.

When should I choose Lite, Fast, or Quality?

Use Lite for rapid, cost-effective ideation and keyframe testing; choose Fast for high-throughput production requiring a balance of speed, fidelity, and 4K support; choose Quality for flagship visual fidelity and commercial-grade finals.

How does per-second pricing support batch production?

Cost is duration (4s, 6s, or 8s) multiplied by the per-second rate of your resolution and audio setting. Preview with audio off at 720p to control spend, then enable audio and elevate to 1080p/4K once motion is locked.

What image specifications are supported?

The endpoint accepts JPEG, PNG, and WebP files up to 10 MB each. High-resolution source images with clear lighting and well-defined subjects yield optimal depth extraction and motion stability.