Veo 3.1 Lite Official Text-to-Video API

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

Veo 3.1 Lite Official is the ultra cost-effective rapid exploration prototype—built for bulk prompt trial-and-error, storyboard drafts, and creative sandboxes. Retain camera control and optional native audio at 720p/1080p with extremely low per-second rates, so you lock the best visual direction before upgrading to Fast or Quality finals.

Input

Prompt

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

Examples

A teenager pops an ollie on a quiet suburban street in the morning, slow motion at board height, dew on the asphalt, sneakers leaving the ground cleanly. Natural sound: the snap of the tail, wheels landing, a distant lawn sprinkler. Realistic motion, no text, no logos.

Macro close-up of steamed milk pouring into espresso, a rosetta pattern forming on the surface, gentle steam, shallow depth of field on a wooden counter. Calm, precise, realistic motion, no text, no logos.

A child runs down a grassy hill flying a red delta kite, wide static shot, the kite climbing into a bright blue sky with slow cumulus clouds. Natural sound: wind over grass, the kite line humming, distant laughter. 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/text-to-video",
  "input": {
    "prompt": "A teenager pops an ollie on a quiet suburban street in the morning, slow motion at board height, dew on the asphalt, sneakers leaving the ground cleanly. Natural sound: the snap of the tail, wheels landing, a distant lawn sprinkler. Realistic 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-lite/text-to-video",
  "input": {
    "prompt": "A teenager pops an ollie on a quiet suburban street in the morning, slow motion at board height, dew on the asphalt, sneakers leaving the ground cleanly. Natural sound: the snap of the tail, wheels landing, a distant lawn sprinkler. Realistic 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.
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	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 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 Text-to-Video API documentation

Veo 3.1 Lite Official Text-to-Video

Google's Veo 3.1 Lite Official text-to-video endpoint handles early creative work at maximum speed and minimum cost. Orchestrate subject motion, camera trajectories, lighting mood, and optional ambient sound through text to batch-produce 4–8 second exploration clips—the best tool for prompt engineering and storyboard drafts.

Why Choose This?

Ultra Cost-Effective Rapid ExplorationGenerate at the family's lowest per-second rates so creative sandboxes, A/B prompt comparisons, and large-scale trial runs stay affordable every day.
Fast Camera & Framing ValidationExercise push, pull, pan, and tracking grammar quickly to verify shot size, subject kinetics, and narrative rhythm before spending on finals.
Optional Native Audio PreviewToggle action-aligned ambience and mechanical Foley when needed—or disable audio during exploration to further compress per-run cost.
Efficient 720p / 1080p LadderStay in HD for exploration instead of burning ultra HD budget early; graduate locked directions to Fast/Quality for 4K finals.
Best Tool for Prompt Trials & Storyboard DraftsPurpose-built for bulk prompt tuning, storyboard previsualization, and creative reviews—the highest-leverage first stop from idea to locked lens language.
Extremely Low Per-Second PricingChoose exact 4, 6, or 8 second durations and independent audio toggles so every exploratory run stays transparent and optimizable.

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. Lite 1080p supports 8 seconds only. 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`720p1080p`
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 camera movement and lighting notes, e.g., 'Low tracking camera at wheel height, warm sunset reflections sliding across panels.' Complex sound cues can wait until later iterations.
Configure Duration and AudioSelect 4, 6, or 8 seconds. For exploration, start with sound: false to maximize throughput; enable native audio only after motion is locked.
Set Resolution and Aspect RatioChoose 16:9 or 9:16. Prefer 720p for bulk trials; switch to 1080p for clearer review (Lite 1080p supports 8 seconds only).
Confirm Pricing and Batch GenerateReview the per-second credit estimate, run multiple prompt variants, shortlist winners, then graduate them to Fast or Quality for finals.

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 Prompt Engineering TrialsParallel-test subject descriptions, camera grammar, and lighting phrasing at minimal cost to locate high-converting prompt combinations fast.
Storyboard & Creative SandboxTurn script beats into motion drafts to align shot size, pacing, and narrative focus before committing higher-tier render budget.
Campaign Concept Pre-ReviewsProduce sufficiently clear audiovisual sketches in budget-sensitive stages so teams can kill or advance directions without premature final spend.
First Stop in a Tiered PipelineServe as the Lite → Fast → Quality entry point: lock framing and motion, then one-click graduate to higher fidelity and 4K finals.

Pro Tips

Structured Prompt Formula: Follow 'Subject Details + Action Progression + Camera Motion + Lighting/Texture + (optional) Sound Design' to keep reusable, high-density templates within 1,000 characters.
Decouple Subject and Camera Motion: Separate clauses for subject action vs. camera path (e.g., 'The runner accelerates across the bridge; the camera keeps pace in a low tracking shot') to compare lens variants cleanly.
Silent First, Audio Later: Disable sound during exploration to focus on framing and kinetics; enable native audio only after the shot is locked.
720p for Volume, 1080p for Review: Run daily A/B at 720p; switch to 1080p when stakeholders need clearer preview (Lite 1080p is 8s only).
Graduate Without Rework Waste: Polish prompts to reusable quality on Lite, then migrate the same prompt set to Fast/Quality—avoid burning high-rate tiers on trial-and-error.

Usage notes

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

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

Veo 3.1 Lite Official is the ultra cost-effective rapid exploration tier of Google's Veo 3.1 family. This endpoint turns text prompts into 4–8 second videos with camera control and optional native audio at 720p/1080p—purpose-built for bulk prompt trials and storyboard drafts via Vidgo API or the online playground.

What model ID should I use in API requests?

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

How should I use native audio on Lite?

Lite supports action-aligned native audio via sound: true. For maximum exploration throughput, keep audio off while iterating prompts; once framing and motion are locked, enable audio for a sync preview before graduating winners to Fast/Quality.

Which resolutions does Lite support, and how does it differ from Fast/Quality?

Lite focuses on 720p and 1080p HD exploration (1080p supports 8 seconds only) and does not offer 4K. This keeps ultra HD budget reserved for locked creatives rendered on Fast or Quality.

How do I efficiently trial camera language on Lite?

Use standard cinematography terms in distinct clauses—e.g., 'slow push-in' or 'low-angle tracking shot'. Parallel-run multiple camera phrasings on Lite to find the strongest lens language at minimal cost, then carry the winning version to higher tiers.

When should I choose Lite instead of Fast or Quality?

Choose Lite for bulk, low-cost validation of prompts, storyboard pacing, and framing feasibility; choose Fast for high-frequency production with 4K headroom; choose Quality for flagship cinematic fidelity. Lite is the highest-leverage first stop in a tiered pipeline.

How do ultra-low per-second rates enable large-scale exploration?

Per-second billing means you only pay for the duration you use. Pair short 4-second tests, audio off, and 720p to minimize each run—so the same budget covers far more prompt variants and camera experiments.

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 Lite Official Image-to-Video endpoint.