Google Veo API Access: What Developers Need to Know (2026)
You want to add AI video generation to your product, you've seen what Veo produces, and your first instinct is to go to Google Cloud and look for a Veo API endpoint. What you find is confusing: there's Vertex AI, there's VideoFX, there's Gemini API — and each has different availability and requirements. This article explains where Veo access actually stands as of August 2026, what options exist, and how developers are integrating Veo 3.1 into production apps today.
What is Google Veo?
Veo is Google DeepMind's video generation model family. Veo 3 and its successor Veo 3.1 generate high-definition video from text prompts (text-to-video) and from input images (image-to-video). Veo 3.1, as of August 2026, also supports reference-to-video — using a reference image to guide visual style or character consistency across frames — and native audio output: ambient sound, background music, and synthesized dialogue embedded directly in the generated clip.
In terms of video quality, Veo 3.1 produces cinematic output with coherent motion, accurate physics, and fine detail at resolutions up to 4K. It is among the highest-quality video generation models available via API today.
Is there a public Google Veo API?
The direct answer: as of August 2026, there is no fully open, self-service Veo API that any developer can sign up for and call immediately through Google Cloud. Access to Veo through Google's own infrastructure is still in a gated phase.
Specifically:
- Google Cloud Vertex AI has a video generation API, but Veo model access requires allowlist approval. Developers submit a request form, and access is reviewed on a case-by-case basis. There is no guaranteed timeline.
- Gemini API (via Google AI Studio and Google Cloud) exposes some video capabilities, but the Veo 3.1 model specifically is not available to all Gemini API users.
- VideoFX (Google Labs) provides a web interface but no programmatic access.
For most developers — particularly indie developers and startups outside the US — waiting for Vertex AI allowlist approval is not a viable path.
How developers are accessing Veo 3.1 today
GenRelay is a generative media API platform that provides developer access to Veo 3.1 via a standard REST endpoint, no Vertex AI account required. GenRelay handles the Google Cloud infrastructure on the backend; you authenticate once with a GenRelay API key and send requests to https://genrelay.ai/v1/videos/generations.
This means:
- No allowlist waiting period
- No Google Cloud billing account or project setup
- One Bearer token for Veo 3.1 and every other model on GenRelay
- Free credits to test before committing to a paid plan
GenRelay positions itself as developer-first API infrastructure — the same model, the same output, accessed through a stable and documented endpoint that your team can integrate in an afternoon.
What does Veo 3.1 cost via GenRelay?
Veo 3.1 Lite pricing on GenRelay is billed per second of output video:
| Resolution | Price per second |
|---|---|
| 720p | $0.060 |
| 1080p | $0.120 |
| 4K | $0.180 |
Billing is on the output video duration, not on generation compute time. A 5-second clip at 720p costs $0.30. At 1080p, the same clip costs $0.60. At 4K, $0.90. Failed generations are not charged.
Example workload math — monthly for an app generating 500 video clips:
| Clip spec | Per-clip cost | Monthly total |
|---|---|---|
| 5s at 720p | $0.30 | $150 |
| 5s at 1080p | $0.60 | $300 |
| 8s at 720p | $0.48 | $240 |
| 8s at 1080p | $0.96 | $480 |
For most consumer app use cases — social clips, product demos, short explainers — 720p at $0.060/s is the right starting point. 1080p makes sense for content being embedded in video players or viewed on desktop.
How do I make my first Veo 3.1 API call?
Veo 3.1 generation is asynchronous. Every request returns a job ID immediately; you poll a separate endpoint until the job reaches completed status, then retrieve the video URL. Here is a complete working example:
import requests
import time
API_KEY = "grk_live_YOUR_KEY_HERE"
BASE = "https://genrelay.ai"
def generate_veo_video(prompt: str, duration: int = 5, resolution: str = "720p") -> str:
"""Submit a Veo 3.1 text-to-video job and return the output URL."""
# Submit the job
resp = requests.post(
f"{BASE}/v1/videos/generations",
headers={"Authorization": f"Bearer {API_KEY}"},
json={
"model": "veo-3.1-lite",
"prompt": prompt,
"duration": duration, # seconds, 5–8 supported
"resolution": resolution, # "720p" | "1080p" | "4k"
}
)
resp.raise_for_status()
job_id = resp.json()["id"]
print(f"Job submitted: {job_id}")
# Poll until complete
for attempt in range(60):
time.sleep(10)
status_resp = requests.get(
f"{BASE}/v1/videos/generations/{job_id}",
headers={"Authorization": f"Bearer {API_KEY}"}
)
data = status_resp.json()
state = data.get("status")
print(f" [{attempt + 1}] status: {state}")
if state == "completed":
return data["video"]["url"]
elif state == "failed":
raise RuntimeError(f"Generation failed: {data.get('error')}")
raise TimeoutError("Job did not complete within 10 minutes")
if __name__ == "__main__":
url = generate_veo_video(
prompt="a slow tracking shot through a dense forest at golden hour, cinematic, 4K",
duration=5,
resolution="720p"
)
print(f"Video ready: {url}")
Polling every 10 seconds is appropriate for Veo 3.1. Most 5-second clips complete in 1–3 minutes. For production, implement an exponential backoff or a webhook alternative — see Veo 3.1 API tutorial for production polling patterns.
What Veo 3.1 modes are available via GenRelay?
GenRelay exposes three Veo 3.1 generation modes:
Text-to-video (t2v): Generate a clip from a text prompt only. The example above uses this mode. Specify model: "veo-3.1-lite" with a prompt and duration.
Image-to-video (i2v): Animate a starting frame. Pass a base64-encoded image or a hosted image URL as init_image in the request body. Veo 3.1 uses the image as the first frame and animates forward from it.
Reference-to-video (ref2v): Use an image to guide visual style or character appearance without animating it directly. Pass the reference as reference_image. The output clip won't necessarily start with that image, but the model uses it for style consistency.
# Image-to-video example
with open("product_shot.jpg", "rb") as f:
img_b64 = __import__("base64").b64encode(f.read()).decode()
resp = requests.post(
f"{BASE}/v1/videos/generations",
headers={"Authorization": f"Bearer {API_KEY}"},
json={
"model": "veo-3.1-lite",
"prompt": "the product slowly rotates 360 degrees on a white surface",
"init_image": img_b64,
"duration": 6,
"resolution": "1080p"
}
)
For a deeper guide on image-to-video specifically — including image dimension requirements and motion prompt tips — see the Veo 3.1 image-to-video API guide.
What resolution and duration are supported?
As of August 2026, Veo 3.1 Lite on GenRelay supports:
- Resolutions: 720p, 1080p, 4K
- Duration: 5–8 seconds per clip
- Output format: MP4, H.264 codec
- Audio: Native audio output is available in t2v and ref2v modes. Specify
generate_audio: trueto enable. Audio is billed as part of the same per-second rate.
Veo 3.1 does not currently support clips longer than 8 seconds in a single generation. For longer sequences, generate multiple clips and concatenate them client-side.
FAQ
Do I need a Google Cloud account to use Veo 3.1 via GenRelay?
No. GenRelay provides access via its own API key system. You sign up at genrelay.ai, generate a key from the dashboard, and start making requests. No Google Cloud account, no Vertex AI project, no billing account on the Google side.
Is Veo 3.1 available to developers outside the US?
Via GenRelay, yes. GenRelay accepts payments via Stripe and supports developers globally. Google's own Vertex AI Veo access is more restricted geographically; GenRelay does not impose the same regional restrictions.
What's the difference between Veo 3 and Veo 3.1?
Veo 3.1 adds three capabilities over Veo 3: native audio output, image-to-video mode, and reference-to-video mode. The underlying video quality is comparable, but the Veo 3.1 Lite variant on GenRelay is the recommended model for new integrations as of August 2026.
Are there content restrictions?
Yes. GenRelay enforces a content policy that prohibits generations involving violence, explicit content, real person likenesses, and copyrighted characters. Prompts that violate the policy return a 400 error with a policy rejection message. The job is not charged.
How do I handle the async pattern in a web API?
The recommended pattern for web backends is: accept the user's request, submit the Veo job, store the job ID in your database, and return the job ID to the client immediately. Run a background worker (a queue consumer or cron job) that polls GenRelay for job completion and updates your database. When the job completes, notify the client via WebSocket or polling on your own status endpoint. This keeps your API response times fast and avoids holding open HTTP connections for 1–3 minutes.
See the full Veo 3.1 API tutorial for a complete async integration example with queue-based polling.