How to Integrate AI Video Generation in Your App

The REST basics: two endpoints, one Bearer key

The veo3gen API is deliberately small. You authenticate every request with an Authorization: Bearer <your-key> header — create the key on the API dashboard once you have an account — and you only ever talk to two routes:

The generate body takes a model (veo3-fast, veo3-quality, or veo3-lite), a prompt, an optional audio flag (default true), an optional base64 image for image-to-video, and an options object for resolution (720p/1080p), aspect ratio (16:9 or 9:16), seed, and negative prompt. The full parameter reference lives in the API documentation, with copy-paste clients for Node.js, Python, and PHP.

The async polling pattern, step by step

Video generation takes minutes, not milliseconds, so the API is fire-and-poll rather than request-and-wait. The pattern every integration follows:

1. 1

   Submit the generation from your server

   POST the prompt and model to /api/generate. The API validates the request, screens the prompt, deducts credits, and immediately returns 202 with a taskId — it never holds your HTTP connection open while the video renders.
2. 2

   Store the taskId and respond to your user

   Persist the taskId against the user or job that requested it, and show a progress state in your UI. The 202 response includes an estimatedTime (1–2 minutes for Lite, 1–3 for Fast, 2–5 for Quality) you can surface directly.
3. 3

   Poll the status endpoint with backoff

   Call GET /api/status/{taskId} on an interval — the API suggests about 10 seconds. Start shorter and back off exponentially (the code below goes 5s to a 30s cap) so fast generations return quickly without hammering the endpoint on slow ones. While in flight, the response reports a progress stage and estimated seconds remaining.
4. 4

   Handle the terminal state

   On completed, read result.videoUrl — a hosted MP4 you can play in a <video> tag or download to your own storage. On failed, read the typed error object and move on: the credits have already been refunded.

Here is the entire pattern in dependency-free JavaScript (Node 18+, native fetch):

const BASE = 'https://api.veo3gen.app';
const KEY = process.env.VEO3GEN_API_KEY; // server-side only

async function generateVideo(prompt) {
  // 1. Submit — returns HTTP 202 + taskId immediately
  const res = await fetch(`${BASE}/api/generate`, {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ model: 'veo3-fast', prompt, audio: true }),
  });
  const { taskId } = await res.json();

  // 2. Poll with exponential backoff (5s -> 30s cap)
  let delay = 5000;
  const deadline = Date.now() + 10 * 60 * 1000;
  while (Date.now() < deadline) {
    await new Promise((r) => setTimeout(r, delay));
    const status = await fetch(`${BASE}/api/status/${taskId}`, {
      headers: { Authorization: `Bearer ${KEY}` },
    }).then((r) => r.json());

    if (status.status === 'completed') return status.result.videoUrl;
    if (status.status === 'failed') {
      // credits are auto-refunded — see status.credits.refunded
      throw new Error(status.error.message);
    }
    delay = Math.min(delay * 1.5, 30000);
  }
  throw new Error('Polling timed out');
}

That one function is a production-shaped integration: submit, poll with backoff, hard deadline, typed failure. Wrap it in your own queue or worker if you batch generations, but nothing more is required to go live.

Error and refund handling: what your integration must expect

Errors come typed, so your integration can branch on errorType instead of parsing messages. The important ones:

The refund rule is the part that simplifies your bookkeeping: credits are deducted when a generation starts and automatically refunded if it fails — timeouts, network faults, filtered outputs, all of it. You never file a ticket or issue a compensating transaction. Every status response carries a credits object with required, charged, and refunded, so a nightly reconciliation job can verify that every failed task shows charged: 0 or a matching refund. The error object also includes a retryable flag, which tells your worker whether resubmitting the same request is worthwhile.

Budgeting credits: what each generation costs your app

Credit costs are fixed per model and resolution, which makes per-feature budgeting straightforward. For an 8-second video with audio:

Shorter clips scale down — 4-second videos cost 0.5x and 6-second videos 0.75x — and the effective price per credit runs $0.213 to $0.250 depending on which pack or subscription you buy (credits are valid at least 30 days from purchase; see Terms). A practical budgeting habit: prototype and iterate on Lite at 3 credits a shot, then re-render the winning prompts on Fast or Quality for production. That typically cuts development-phase spend by two-thirds without touching final output quality.