Veo3.1 Lite Image to Video API

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

Google Veo 3.1 Lite Image-to-Video transforms static images into high-fidelity 720p or 1080p videos with natively generated audio. Supports many interpolation use cases, landscape and portrait aspect ratios, and customizable duration. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing.

Image to Video
Input

Drag & drop or click to upload

preview

Idle

$0.05per run·~20 / $1

ExamplesView all

A couple sharing a bicycle glides slowly down a park path on a breezy afternoon. Camera pulls back in a wide tracking shot as they move through dappled light filtering through trees. The woman's hat brim flutters, she turns slightly to look at him. He smiles without looking back. Shallow depth of field, golden overcast sky, 24fps cinematic grade, quiet intimacy.

Related Models

README

Veo 3.1 Lite Image-to-Video

Veo 3.1 Lite is an efficient image-to-video model, generating high-quality cinematic video from an input image and a natural language prompt at accessible pricing. With native synchronized audio generation, negative prompt guidance, landscape and portrait aspect ratios, and resolution up to 1080p, it brings still images to life for a wide range of creative and production workflows.

Why Choose This?

  • High-quality image animation Uses your input image as the starting frame and adds motion guided by your text description.

  • Negative prompt guidance Describe unwanted elements to guide generation. Exclusion of specific elements is not guaranteed.

  • Resolution options Generate at 720p or 1080p to match your quality and budget requirements. 1080p requires an 8-second duration.

  • Flexible aspect ratios Supports landscape 16:9 and portrait 9:16 for cinematic and social formats.

  • Seed control Set a seed when experimenting with generation settings. Identical outputs are not guaranteed.

  • Synchronized audio Generates audio alongside the video. Describe dialogue, sound effects, and ambient sounds in your prompt.

Parameters

ParameterRequiredDescription
promptYesText description of the desired motion, camera movement, and atmosphere. May include dialogue and sound cues.
imageYesInput image to animate. Upload an image in the Playground or provide its URL in the API request.
aspect_ratioNoOutput aspect ratio: 16:9 or 9:16. Default: 16:9.
durationNoClip length in seconds: 4, 6, or 8. Default: 8. Must be 8 when resolution is 1080p.
resolutionNoOutput resolution: 720p or 1080p. Default: 720p. 1080p requires duration to be 8.
negative_promptNoGuidance describing elements to avoid in the generated video; exclusion is not guaranteed.
seedNoRandom seed for generation. Does not guarantee identical results.

How to Use

  1. Upload your image — choose a clear image containing the subject and composition you want to animate.
  2. Write your prompt — describe how the subject and camera should move. Include atmosphere, sound effects, or dialogue if needed.
  3. Select aspect ratio — choose 16:9 for landscape or 9:16 for portrait.
  4. Set duration — choose 4, 6, or 8 seconds. Keep the duration at 8 seconds when using 1080p.
  5. Select resolution — 720p for standard output, 1080p for higher-resolution results.
  6. Add negative prompt (optional) — describe elements you want the model to avoid.
  7. Set seed (optional) — specify a seed for controlled experimentation, without expecting exact reproduction.
  8. Submit — generate, preview, and download your video.

Pricing

ResolutionDurationCost
720p4s$0.20
720p6s$0.30
720p8s$0.40
1080p8s$0.64

Best Use Cases

  • Cinematic Storytelling — Animate a still frame into an atmospheric, narrative-driven scene.
  • Social Media Content — Turn portraits, illustrations, and other images into short video clips with synchronized audio.
  • Marketing & Advertising — Bring product images and campaign visuals to life with motion.
  • Concept Visualization — Explore how a character, environment, or visual concept could move on screen.
  • Audio-Visual Content — Combine image animation with ambient sounds, dialogue, and sound effects.

Pro Tips

  • Start with a clear, well-composed image that shows the subject you want to animate.
  • Focus your prompt on motion, camera movement, and changes over time rather than repeating everything already visible in the image.
  • Choose an output aspect ratio that matches your source image where possible.
  • Use negative_prompt as guidance for unwanted elements rather than a strict exclusion rule.
  • Use 720p to rapidly test and iterate before committing to an 8-second 1080p final render.
  • Keep the image, prompt, and settings consistent when comparing results; a fixed seed does not guarantee identical output.
  • Include clear audio cues in your prompt when particular sounds or dialogue are important.

Notes

  • Both prompt and image are required; all other parameters are optional.
  • The default output settings are 720p, 8 seconds, and 16:9.
  • 720p supports 4-, 6-, and 8-second generation. 1080p requires an 8-second duration.
  • Audio generation is enabled by default.
  • Please follow applicable content usage policies when providing images and crafting prompts.

Related Models

Note:This website uses AI models provided by third parties. Documentation prices are for reference and may be outdated. The Generate button shows an estimate; the final task charge prevails.

Veo3.1 Lite Image To Video API — Quick start

Grab a WaveSpeedAI API key, then call POST https://api.wavespeed.ai/api/v3/google/veo3.1-lite/image-to-video with your input as JSON. The endpoint returns a prediction id. Start polling the result endpoint around every 2 seconds, increase the interval for long-running tasks, and stop on any terminal status. On completed, read output values from data.outputs. Examples for Veo3.1 Lite Image To Video below.

HTTP example
set -euo pipefail

: "${WAVESPEED_API_KEY:?Set WAVESPEED_API_KEY}"

REQUEST_BODY=$(cat <<'JSON'
{
    "prompt": "A cinematic shot of a city at sunset, soft golden light",
    "image": "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg",
    "aspect_ratio": "16:9",
    "duration": 8,
    "resolution": "720p"
}
JSON
)

# 1. Submit the prediction.
SUBMIT_RESPONSE=$(curl --silent --show-error --fail-with-body \
  -X POST "https://api.wavespeed.ai/api/v3/google/veo3.1-lite/image-to-video" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $WAVESPEED_API_KEY" \
  -d "$REQUEST_BODY")

TASK=$(printf '%s' "$SUBMIT_RESPONSE" | jq 'if has("data") then .data else . end')
PREDICTION_ID=$(printf '%s' "$TASK" | jq -r '.id')
if [ -z "$PREDICTION_ID" ] || [ "$PREDICTION_ID" = "null" ]; then
  printf 'Submission response did not contain a prediction id
' >&2
  exit 1
fi
RESULT_URL="https://api.wavespeed.ai/api/v3/predictions/$PREDICTION_ID/result"

# 2. Poll until the prediction finishes.
while true; do
  RESPONSE=$(curl --silent --show-error --fail-with-body "$RESULT_URL" \
    -H "Authorization: Bearer $WAVESPEED_API_KEY")
  RESULT=$(printf '%s' "$RESPONSE" | jq 'if has("data") then .data else . end')
  STATUS=$(printf '%s' "$RESULT" | jq -r '.status')
  case "$STATUS" in
    completed) printf '%s\n' "$RESULT" | jq '.outputs'; break ;;
    failed|cancelled|timeout|deleted) printf '%s\n' "$RESULT" | jq . >&2; exit 1 ;;
    *) sleep 2 ;;
  esac
done
Node.js example
const submitUrl = "https://api.wavespeed.ai/api/v3/google/veo3.1-lite/image-to-video";
const apiKey = process.env.WAVESPEED_API_KEY;
if (!apiKey) throw new Error('Set WAVESPEED_API_KEY');

async function requestJson(url, options = {}) {
  const response = await fetch(url, options);
  if (!response.ok) throw new Error(await response.text());
  return response.json();
}

// 1. Submit the prediction.
const body = await requestJson(submitUrl, {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${apiKey}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
        "prompt": "A cinematic shot of a city at sunset, soft golden light",
        "image": "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg",
        "aspect_ratio": "16:9",
        "duration": 8,
        "resolution": "720p"
}),
});
const task = body.data ?? body;
if (!task.id) throw new Error("Submission response did not contain a prediction id");
const resultUrl = `https://api.wavespeed.ai/api/v3/predictions/${task.id}/result`;

// 2. Poll until the prediction finishes.
while (true) {
  const resultBody = await requestJson(resultUrl, {
    headers: { "Authorization": `Bearer ${apiKey}` },
  });
  const result = resultBody.data ?? resultBody;
  if (result.status === "completed") {
    console.log(result.outputs);
    break;
  }
  if (["failed", "cancelled", "timeout", "deleted"].includes(result.status)) throw new Error(JSON.stringify(result));
  await new Promise(resolve => setTimeout(resolve, 2000));
}
Python example
import json
import os
import time
from urllib.request import Request, urlopen

api_key = os.environ["WAVESPEED_API_KEY"]
headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
payload = {
    "prompt": "A cinematic shot of a city at sunset, soft golden light",
    "image": "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg",
    "aspect_ratio": "16:9",
    "duration": 8,
    "resolution": "720p"
}

def request_json(url, data=None):
    request = Request(url, data=data, headers=headers, method="POST" if data else "GET")
    with urlopen(request) as response:
        return json.load(response)

# 1. Submit the prediction.
body = request_json("https://api.wavespeed.ai/api/v3/google/veo3.1-lite/image-to-video", json.dumps(payload).encode())
task = body.get("data", body)
if not task.get("id"):
    raise RuntimeError("Submission response did not contain a prediction id")
result_url = f"https://api.wavespeed.ai/api/v3/predictions/{task['id']}/result"

# 2. Poll until the prediction finishes.
while True:
    result_body = request_json(result_url)
    result = result_body.get("data", result_body)
    status = result.get("status")
    if status == "completed":
        print(result.get("outputs", []))
        break
    if status in {"failed", "cancelled", "timeout", "deleted"}:
        raise RuntimeError(result)
    time.sleep(2)

Veo3.1 Lite Image To Video API — Frequently asked questions

What is the Veo3.1 Lite Image To Video API?

Veo3.1 Lite Image To Video is a Google model for video generation from images, exposed as a REST API on WaveSpeedAI. Google Veo 3.1 Lite Image-to-Video transforms static images into high-fidelity 720p or 1080p videos with natively generated audio. Supports many interpolation use cases, landscape and portrait aspect ratios, and customizable duration. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing. You can call it programmatically or try it from the playground above.

How do I call the Veo3.1 Lite Image To Video API?

POST your input parameters to the model's REST endpoint (shown in the API tab of this playground) with your WaveSpeedAI API key in the Authorization header. Submission returns a prediction ID. Poll the result endpoint starting around every 2 seconds, increase the interval for long-running tasks, and stop on any terminal status. The playground generates Python, JavaScript, and cURL examples for submitting requests and polling results. Full request/response shape is documented at https://wavespeed.ai/docs/docs-api/google/veo3.1-lite/image-to-video.

How much does Veo3.1 Lite Image To Video cost per run or per second?

Veo3.1 Lite Image To Video starts at $0.05 per run or per second. That figure is the base price — the final charge scales with the parameters you set in the form (output size, length, count, references, or whatever knobs this model exposes), so a higher-quality or larger output costs more than a minimal one. The exact cost for your current input is shown live next to the Generate button before you submit, and the actual per-call charge is recorded on the prediction afterwards.

What inputs does Veo3.1 Lite Image To Video accept?

Key inputs: `prompt`, `image`, `aspect_ratio`, `resolution`, `duration`, `seed`. The full JSON schema (types, defaults, allowed values) is rendered above the Generate button and mirrored in the API reference at https://wavespeed.ai/docs/docs-api/google/veo3.1-lite/image-to-video.

How long does Veo3.1 Lite Image To Video take to generate?

Reported generation time on WaveSpeedAI is around 49 seconds per request. This is an estimate, not a latency guarantee; queue time and input settings can change the total wait. live status is visible in the prediction record.

Can I use Veo3.1 Lite Image To Video outputs commercially?

Commercial usage rights depend on the model's license, set by its provider (Google). Check the provider's applicable terms and WaveSpeedAI's Terms of Service before commercial use.

llms.txt — google/veo3.1-lite/image-to-video for AI agents and LLMs