Veo 3.1 Lite Official Image-to-Video API

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

Veo 3.1 Lite Official is the ultra cost-effective rapid image-to-video exploration prototype: awaken a single start frame, or draft first-to-last transitions with dual keyframes. Retain camera control and optional native audio at 720p/1080p with extremely low per-second rates—so you lock the best motion path before committing Fast/Quality finals.

Input

Prompt

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

Examples

The guitarist by the campfire strums a slow chord progression, sparks rising into the night sky, firelight flickering across the guitar body and the surrounding pines. Natural sound: fingerpicked acoustic guitar, crackling fire, crickets. Realistic motion, no text, no logos.

A paper lantern hanging in a quiet dusk alley flickers alive and settles into a warm amber glow, swaying subtly in a light breeze, shadows softening on the wall behind it. Calm, realistic motion, no text, no logos.

A glass wind chime on a farmhouse porch sways gently in the morning breeze, sunlight scattering through the glass pieces onto the wooden rail. Natural sound: soft chiming, light wind, a rooster crowing far away. Realistic 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-lite/image-to-video",
  "input": {
    "prompt": "The guitarist by the campfire strums a slow chord progression, sparks rising into the night sky, firelight flickering across the guitar body and the surrounding pines. Natural sound: fingerpicked acoustic guitar, crackling fire, crickets. 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-lite-official/image-to-video/v1/01/input-start-frame.png"
    ]
  }
}
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-lite/image-to-video",
  "input": {
    "prompt": "The guitarist by the campfire strums a slow chord progression, sparks rising into the night sky, firelight flickering across the guitar body and the surrounding pines. Natural sound: fingerpicked acoustic guitar, crackling fire, crickets. 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-lite-official/image-to-video/v1/01/input-start-frame.png"
    ]
  }
}
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.
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	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 3.6 credits/s; audio 6 credits/s. 1080p silent 6 credits/s; audio 9.6 credits/s, 8 seconds only.

View Veo 3.1 Lite Official Image-to-Video API documentation

Veo 3.1 Lite Official Image-to-Video

Google's Veo 3.1 Lite Official image-to-video endpoint is built for low-cost motion exploration of visual assets. Launch from a start frame or validate transitions with first/last-frame pairs, directing camera and optional sound via text to batch-convert product shots and concept art into 4–8 second motion drafts—the best first stop for prompt and keyframe prototyping.

Why Choose This?

Rapid Start-Frame Motion DraftsInherit composition and lighting from the source image to validate opening motion at minimal cost—ideal for bulk asset screening.
First/Last-Frame Transition PrototypingTrial pose and environment shifts with dual keyframes cheaply, then elevate proven transition rhythms to higher tiers for polish.
Ultra Cost-Effective Exploration ThroughputThe family's lowest per-second rates enable parallel trial runs for product motion, character awakening, and transition sandboxes at scale.
Optional Native Audio PreviewEnable action-aligned ambience when needed—or disable audio during exploration to spend budget on more motion variants instead.
Efficient 720p / 1080p LadderStay in HD for exploration instead of burning 4K budget early; graduate locked motion to Fast/Quality for ultra HD finals.
Extremely Low Per-Second PricingExact duration control and independent audio toggles keep every keyframe trial transparent and continuously optimizable.

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. Lite 1080p supports 8 seconds only. Lite first/last-frame jobs also support 8 seconds only. 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`720p1080p`
sound	Optional	Boolean. Enables native audio; the Playground defaults to true. Default`truefalse`

How to Use

Upload a Clear Start ImageChoose a well-lit image with a distinct subject (JPEG/PNG/WebP, up to 10MB) to ground the opening composition for motion drafts.
Optionally Add an End Frame for Transition DraftsTo validate a closing pose or composition shift, add an optional last frame. Dual images enter first/last-frame mode—ideal for low-cost transition trials.
Direct Motion and Camera via PromptGuide progression from the opening frame, e.g., 'The subject turns toward the floor-to-ceiling window as the camera tracks forward.' Complex sound cues can wait until later iterations.
Configure Aspect Ratio, Duration & AudioUse 'auto' to inherit source framing or choose 16:9/9:16. Prefer 720p with audio off for bulk trials (Lite 1080p and first/last-frame jobs support 8 seconds only).
Confirm Pricing, Shortlist & GraduateReview the per-second estimate, batch-run variants, shortlist the best motion and transition paths, then upgrade to Fast or Quality for audio-enabled HD/4K delivery.

Pricing

Veo 3.1 Lite 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 Lite 720p audio job uses 8 x 6 = 48 credits, about $0.24 at the base API credit rate.

Usage	Rate	Details
720p, no audio	3.6 credits/sec ($0.018/sec)	8 seconds = 28.8 credits ($0.144).
720p, audio	6 credits/sec ($0.03/sec)	Default 720p / 8s audio costs 48 credits ($0.24).
1080p, no audio (8s only)	6 credits/sec ($0.03/sec)	Lite 1080p supports 8 seconds only.
1080p, audio (8s only)	9.6 credits/sec ($0.048/sec)	Lite 1080p supports 8 seconds only.

Best Use Cases

Bulk E-Commerce Hero Motion DraftsValidate turntable, macro, and lighting-sweep ideas on product stills at minimal cost, then graduate winners to production renders.
Character & Concept Art Awakening TrialsParallel-test body rhythm and breathing motion on key art to find the most natural awakening before higher-tier polish.
Keyframe Transition SandboxesCompare multiple first/last-frame paths and camera drifts cheaply, locking feasible pacing before investing in premium refinement.
Image-to-Video Entry in a Tiered PipelineServe as the Lite → Fast → Quality image-driven first stop: confirm subject consistency and transition feasibility, then upgrade for finals.

Pro Tips

Respect Source Framing and Physics: Ground prompts in the start frame's geometry, lighting, and depth—avoid contradictory instructions during exploration.
Focus Keyframe Prompts on the Middle Path: In dual-image mode, describe how the shot moves from A to B—subject path, camera drift, and transition rhythm—so variants stay comparable.
Preserve Composition with 'auto': Set aspect_ratio to 'auto' during exploration so cropping does not distract from judging motion itself.
Silent First, Audio Later: Disable sound for bulk drafts; enable native audio only after motion is locked for a sync check.
Graduate Without Rework Waste: Polish first/last-frame pairs and prompts to reusable quality on Lite, then migrate to Fast/Quality—avoid burning high-rate tiers on trial-and-error.

Usage notes

Veo 3.1 Lite 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.
Lite Official supports 720p and 1080p only. Lite 1080p supports 8 seconds only.
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 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-Video API frequently asked questions

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

Veo 3.1 Lite Official Image-to-Video is the ultra cost-effective rapid exploration tier for image-driven generation in Google's Veo 3.1 family. Draft motion from a single start frame or validate first/last-frame transitions at 720p/1080p with optional native audio—built for bulk asset screening and keyframe prototyping via Vidgo API or the playground.

What model ID should I use in API requests?

Set the model field to google/veo3.1-lite/image-to-video. For Fast or Quality, use google/veo3.1-fast/image-to-video and google/veo3.1/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. One image activates start-frame mode for rapid opening-motion validation. Two images activate first/last-frame mode (automatically submitting generation_type: "frame") for low-cost transition drafts (Lite dual-image jobs support 8 seconds only).

How should I use native audio on Lite image-to-video most efficiently?

Lite supports action-aligned native audio via sound: true. Keep audio off during bulk motion/keyframe trials; enable it for a sync preview once the transition is locked, then graduate winners to Fast/Quality for finals.

How does 'auto' aspect ratio help exploration?

Choosing 'auto' preserves the source image's native ratio so cropping does not distract from judging motion and transitions. Specify 16:9 or 9:16 when you need channel-specific review framing.

When should I choose Lite, Fast, or Quality?

Choose Lite for rapid, cost-effective validation of animation feasibility and keyframe transitions; choose Fast for high-throughput production with 4K headroom; choose Quality for flagship fidelity and commercial finals. Lite is the highest-leverage first stop in an image-driven tiered pipeline.

What practical notes apply to Lite resolution and duration?

Lite supports 720p and 1080p (no 4K). 1080p and first/last-frame (dual-image) jobs support 8 seconds only. Prefer 720p during exploration; switch to 1080p when stakeholders need a clearer internal review.

What image specifications are supported?

The endpoint accepts JPEG, PNG, and WebP files up to 10 MB each. Clear subjects and well-defined lighting help the model extract structure and depth more stably—raising draft success rates.