Veo 3.1 API Access: The Developer's Onboarding Guide

Authentication: one key, two header styles

Every request authenticates with an API key you create from the API dashboard after signing in with Google. Keys are prefixed veo_, are active the moment they're created, and can be scoped and revoked independently — so you can issue one per environment or per app instead of sharing a single secret.

Send the key on every request using either header style — the standard Authorization header is recommended:

Authorization: Bearer veo_your_api_key_here
# or, equivalently:
X-API-Key: veo_your_api_key_here

That's the entire auth story. Compare that with going through Vertex AI directly, where the same first call requires a Google Cloud project, billing setup, service-account JSON, and OAuth token refresh logic. If you're weighing key setup against total spend, the companion piece on Veo 3.1 API access cost breaks down the key-plus-pricing angle in detail.

The three endpoints you'll actually use

The API surface is deliberately small. Generation is asynchronous: you submit a job, get a taskId back immediately, then poll for the finished video.

Full parameter tables for every field live in the API documentation; the essentials are model, prompt, audio (default true), modelVersion, and an options object for resolution (720p/1080p), aspectRatio (16:9 or 9:16), duration (4, 6, or 8 seconds), seed, negativePrompt, and enhancePrompt.

Available models and what each costs per credit

Three model ids cover the speed/quality/price spectrum. Credits cost between $0.213 and $0.250 each depending on the plan you choose (one-time packs from $9.99 for 40 credits; monthly subscriptions from $9.99 for 45). Prices below are per 8-second video with audio:

Shorter clips cost proportionally less: 4-second videos are billed at 0.5× and 6-second videos at 0.75× of the 8-second rate. For most production integrations, veo3-fast is the default choice — at roughly $0.07–$0.10 per second of finished video with audio, it undercuts direct Vertex AI access, which as of 2026 has been priced around $0.75 per second for Veo with audio. Lite is the budget tier for drafts and high-volume pipelines; Quality (and its 4K option, exclusive to Veo 3.1) is for final renders.

Request and response: a complete example

Here is the full round trip. First, submit a generation — this example requests Veo 3.1 Fast, vertical 1080p, with audio:

curl -X POST https://api.veo3gen.app/api/generate \
  -H "Authorization: Bearer veo_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "veo3-fast",
    "modelVersion": "3.1",
    "prompt": "A majestic eagle soaring over snow-capped mountains",
    "audio": true,
    "options": {
      "aspectRatio": "9:16",
      "resolution": "1080p"
    }
  }'

The API responds immediately with a task id:

{
  "success": true,
  "taskId": "veo_1704067200000_abc123",
  "status": "pending",
  "model": "veo3-fast",
  "creditsRequired": 10,
  "resolution": "1080p",
  "estimatedTime": "1-3 minutes"
}

Poll the status endpoint every few seconds until status is completed:

curl -H "Authorization: Bearer veo_your_api_key_here" \
  https://api.veo3gen.app/api/status/veo_1704067200000_abc123

{
  "success": true,
  "taskId": "veo_1704067200000_abc123",
  "status": "completed",
  "result": {
    "videoUrl": "https://storage.googleapis.com/.../video.mp4",
    "duration": 8,
    "resolution": "1080p",
    "aspectRatio": "9:16",
    "hasAudio": true
  },
  "credits": { "required": 10, "charged": 10, "refunded": 0 }
}

Because it's plain HTTPS and JSON, the same flow works unchanged from Node, Python, PHP, Go, or a serverless function — no vendor SDK to install. Validation errors come back as HTTP 400 with a field pointer, and prompts that violate content policy are rejected up front with errorType: "CONTENT_POLICY_VIOLATION" before any credits are charged.

Rate limits and how to handle them

Two limits protect the service, and both return HTTP 429 with errorType: "RATE_LIMIT_EXCEEDED" when hit:

In practice the per-key limit is the one to design around. Since generation is asynchronous, one video consumes a handful of requests (one submit plus a few status polls) — so 100 requests/hour comfortably supports dozens of videos per hour if you poll politely. Poll at 5–10 second intervals rather than in a tight loop, back off exponentially on 429s, and issue separate keys per service so one busy worker can't starve another.

From zero to first video in four steps

1. 1

   Sign in and create an API key

   Sign in with Google and open the API dashboard. Create a key — it's active immediately. No credit card is required to sign up.
2. 2

   Add credits sized to your workload

   Pick a plan on the pricing page: one-time packs (Basic $9.99/40 credits, Hero $37.50/160, Studio $79.99/350) for bursty usage, or monthly subscriptions ($9.99/45, $37.50/175, $79.99/375) for steady pipelines. Credits are valid at least 30 days from purchase (see Terms).
3. 3

   Send your first POST /api/generate

   Copy the curl example above, swap in your key and prompt, and pick a model — veo3-lite is the cheapest way to smoke-test the integration at ~3 credits per video.
4. 4

   Poll status and store the video

   Poll GET /api/status/:taskId until completed, then download the videoUrl and persist it on your side. Use GET /api/logs to audit usage and credits across your whole history.

Prefer to validate prompts by hand before wiring code? The web generator uses the same models and credits, so you can prototype a prompt in the browser and ship the exact string through the API.