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.
Idle
$0.05per run·~20 / $1
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.
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.
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.
| Parameter | Required | Description |
|---|---|---|
| prompt | Yes | Text description of the desired motion, camera movement, and atmosphere. May include dialogue and sound cues. |
| image | Yes | Input image to animate. Upload an image in the Playground or provide its URL in the API request. |
| aspect_ratio | No | Output aspect ratio: 16:9 or 9:16. Default: 16:9. |
| duration | No | Clip length in seconds: 4, 6, or 8. Default: 8. Must be 8 when resolution is 1080p. |
| resolution | No | Output resolution: 720p or 1080p. Default: 720p. 1080p requires duration to be 8. |
| negative_prompt | No | Guidance describing elements to avoid in the generated video; exclusion is not guaranteed. |
| seed | No | Random seed for generation. Does not guarantee identical results. |
| Resolution | Duration | Cost |
|---|---|---|
| 720p | 4s | $0.20 |
| 720p | 6s | $0.30 |
| 720p | 8s | $0.40 |
| 1080p | 8s | $0.64 |
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.
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
doneconst 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));
}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 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.
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.
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.
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.
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.
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.