# How to Generate AI Video with Veo 3.1 via the Google Flow API

> Source: <https://dev.to/useapi/how-to-generate-ai-video-with-veo-31-via-the-google-flow-api-2g4i>
> Published: 2026-06-18 04:23:24+00:00

** Veo 3.1, Google's flagship video model, runs from a single curl through useapi.net.** You drive your own

The official Gemini API and Vertex meter Veo per second of output. This third-party [Google Flow API](https://useapi.net/docs/api-google-flow-v1) runs on a flat [subscription](https://useapi.net/docs/subscription) instead — you spend your normal Flow credits plus one monthly fee for API access, far cheaper per clip. Below: the models you get, the price gap versus the official API, then the two-call workflow and a runnable batch script.

Pick a model per request with the `model`

field (default `veo-3.1-fast`

). Credit costs come from Google's [official Flow credits table](https://support.google.com/flow/answer/16526234):

| Model id | Tier / speed | Durations | Credits per generation |
|---|---|---|---|
`veo-3.1-lite` |
Cheapest Veo | 4s, 6s, 8s | 10 (Non-Ultra) · 5 (Ultra) |
`veo-3.1-lite-low-priority` |
Lite, lower priority | 4s, 6s, 8s | 0 — Ultra $199 only |
`veo-3.1-fast` (default)
|
Fast Veo | 4s, 6s, 8s | 20 (Non-Ultra) · 10 (Ultra) |
`veo-3.1-quality` |
Highest-quality Veo | 8s only | 100 |
`omni-flash` |
Gemini Omni Flash, audio-native | 4s, 6s, 8s, 10s | 15 / 20 / 25 / 30 (by length) |

Notes from the [overview](https://useapi.net/docs/api-google-flow-v1): `4s`

/`6s`

are Ultra-only on Veo, `veo-3.1-quality`

is `8s`

only, `veo-3.1-lite-low-priority`

costs 0 credits but is available only to Google AI Ultra $199 subscribers, and `10s`

clips are `omni-flash`

only. Google Flow can also generate stills with Imagen 4 and the Nano Banana models via the separate [POST /images](https://useapi.net/docs/api-google-flow-v1/post-google-flow-images) endpoint.

You spend your Google AI plan's Flow credits as usual, plus a flat [$15/month](https://useapi.net/docs/subscription) to useapi.net for API access to every supported service — no per-call surcharge.

Third-party [Google Flow API](https://useapi.net/docs/api-google-flow-v1) by [useapi.net](https://useapi.net/) vs. the official [Gemini API](https://ai.google.dev/gemini-api/docs/pricing) — drive your own Google Flow subscription instead of metered, per-call API billing:

| Model | Official Gemini API | useapi.net (Flow Pro) | useapi.net (Flow Ultra) |
|---|---|---|---|
| Veo 3.1 Fast — 8s clip | $0.80 | ~$0.40 | ~$0.10 |
| Veo 3.1 Quality — 8s clip | $3.20 | ~$2.00 | ~$1.00 |
| Veo 3.1 Lite — 8s clip | $0.40 | ~$0.20 | ~$0.05 |
| Veo 3.1 Lite, lower priority | — | — | $0 (Ultra $199)
|
| Gemini Omni Flash — 8s clip | — (Flow only)
|
~$0.50 | ~$0.25 |
| Nano Banana Pro — per image | $0.134 | included | included |
| Nano Banana — per image | $0.039 | included | included |
| Imagen 4 — per image | metered | included | included |

Expected daily output — Ultra ($199/mo) plan. Daily averages observed on top real accounts. These are expected, not guaranteed: Google governs the underlying Flow allowances and they vary with demand.

| Free workload (no Flow credits spent) | Avg generations / day* |
|---|---|
| Veo 3.1 Lite — lower priority video | ~1,000 |
| Images — Nano Banana, Nano Banana Pro, Imagen 4 | up to ~500 |

*Averages from the busiest real accounts — not guarantees. They are set by Google's own allowances and fluctuate with demand. Applies only to the free lower-priority video queue and image generation. Credit-metered models (Veo 3.1 Fast / Quality and Gemini Omni Flash) are not shown here — their volume is bounded by your plan's monthly Flow credits (see the [credit table](https://useapi.net/docs/api-google-flow-v1)), not a free allowance.

Veo is billed per second on the Gemini API (an 8-second 720p clip shown) and images are priced per image. Through useapi.net you spend your own Flow plan credits and pay a flat [$15/month](https://useapi.net/docs/subscription) — image generation is included on any Google AI plan, and there is no Google Cloud project, API key, or per-call metering.

Full per-tier credit allowances and the per-model cost breakdown live on the [Google Flow overview](https://useapi.net/docs/api-google-flow-v1). See the [setup guide](https://useapi.net/docs/start-here/setup-google-flow) to connect your account.

You need a useapi.net [API token](https://useapi.net/docs/start-here/setup-useapi) and a connected [Google Flow account](https://useapi.net/docs/start-here/setup-google-flow). Generation is asynchronous: pass `async: true`

and the create call returns a `jobid`

immediately, then you poll until the video is ready.

`POST https://api.useapi.net/v1/google-flow/videos`

:

```
curl -X POST "https://api.useapi.net/v1/google-flow/videos" \
  -H "Authorization: Bearer $USEAPI_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A serene mountain landscape at sunset, camera slowly panning right",
    "model": "veo-3.1-fast",
    "aspectRatio": "landscape",
    "duration": 8,
    "async": true
  }'
```

In async mode the response returns immediately with `201 Created`

, a lowercase `jobid`

, and `status: "created"`

:

```
{
  "jobid": "j1731859234567v-u12345-email:jo***@gmail.com-bot:google-flow",
  "type": "video",
  "status": "created",
  "created": "2026-06-15T12:34:56.789Z",
  "request": {
    "async": true,
    "prompt": "A serene mountain landscape at sunset, camera slowly panning right",
    "model": "veo-3.1-fast",
    "aspectRatio": "landscape",
    "duration": 8
  }
}
```

`GET https://api.useapi.net/v1/google-flow/jobs/{jobId}`

:

```
curl "https://api.useapi.net/v1/google-flow/jobs/{jobId}" \
  -H "Authorization: Bearer $USEAPI_TOKEN"
```

`status`

moves through `created`

→ `started`

→ `completed`

. When it reaches `completed`

, the finished MP4 is in `response.media[].videoUrl`

(a single prompt with `count > 1`

returns one entry per clip):

```
{
  "jobid": "j1731859234567v-...",
  "type": "video",
  "status": "completed",
  "response": {
    "media": [
      {
        "mediaGenerationId": "user:12345-email:6a6f...-video:a1d95d21-...",
        "videoUrl": "https://flow-content.google/video/a1d95d21-...?Expires=...",
        "thumbnailUrl": "https://flow-content.google/image/a1d95d21-...?Expires=..."
      }
    ],
    "remainingCredits": 18760
  }
}
```

Veo 3.1 typically finishes in 60–180 seconds depending on model and mode. The signed `videoUrl`

is valid for about 24 hours, so download promptly. Prefer not to poll? Pass a `replyUrl`

in the create body to receive a webhook callback when the job completes.

Veo takes image inputs two different ways. Upload each image first with [POST /assets/ email](https://useapi.net/docs/api-google-flow-v1/post-google-flow-assets-email) (raw bytes, an image

`Content-Type`

, PNG/JPEG/WebP up to 20 MB). The upload response nests the id at `mediaGenerationId.mediaGenerationId`

— that nested string is what you pass back. When you supply any image input you can omit `email`

: the request routes to the account where the image was uploaded.Your image becomes a literal frame of the clip. Pass it as `startImage`

to start from that frame:

```
curl -X POST "https://api.useapi.net/v1/google-flow/videos" \
  -H "Authorization: Bearer $USEAPI_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Brave Captain Cat chasing away the pirates!",
    "model": "veo-3.1-fast",
    "aspectRatio": "portrait",
    "startImage": "user:12345-email:6a6f...-image:ff9aa5cc-...",
    "async": true
  }'
```

Add `endImage`

(a second uploaded reference id) to pin the last frame so Veo generates the transition between the two. `endImage`

requires `startImage`

— end-frame-only is not supported. On `omni-flash`

, only `startImage`

is accepted.

Your images guide the whole clip — subject, character, or style — rather than a specific frame. Pass `referenceImage_1`

through `referenceImage_3`

(Veo accepts up to 3, on 8-second clips only, and not on `veo-3.1-quality`

). R2V cannot be combined with `startImage`

/`endImage`

:

```
curl -X POST "https://api.useapi.net/v1/google-flow/videos" \
  -H "Authorization: Bearer $USEAPI_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A lady says to the dog, \"Say meow meow meow.\" The dog looks at the lady with a surprised, frustrated look and woofs in a human voice, \"What the heck lady?!\"",
    "model": "veo-3.1-fast",
    "aspectRatio": "portrait",
    "referenceImage_1": "user:12345-email:6a6f...-image:abcde-...",
    "async": true
  }'
```

Mention each reference inline with an `@referenceImage_N`

marker in the prompt, add a `referenceAudio_1`

(a system voice name like `Zephyr`

) for narration, or pass a reusable [character](https://useapi.net/docs/api-google-flow-v1/post-google-flow-characters) as `character_1`

(it drives the same R2V mode and counts toward the 3-reference budget). Omni Flash takes references further — up to 7, plus video-to-video editing and synced voices — see the [Omni Flash tutorial](https://useapi.net/docs/articles/omni-flash-bash).

Finding the right shot takes many attempts, and running them by hand is tedious. The Node.js script reads a list of prompts from [ prompts.json](https://github.com/useapi/google-flow-api/blob/main/veo-video/prompts.json), uploads any start/end frame images, submits each job in async mode, then polls and downloads every finished MP4 — so you can queue a batch and come back to the winners.

You need [Node.js](https://nodejs.org) v21 or newer. Put `prompts.json`

and [ google-flow.mjs](https://github.com/useapi/google-flow-api/blob/main/veo-video/google-flow.mjs) in the same folder and run

`node ./google-flow.mjs API_TOKEN EMAIL`

, where `API_TOKEN`

is your useapi.net `EMAIL`

is your connected `health`

field before submitting.Prefer to clone and run it locally? The complete `google-flow.mjs`

and `prompts.json`

are on GitHub in [ useapi/google-flow-api](https://github.com/useapi/google-flow-api/tree/main/veo-video).

Real Veo 3.1 clips generated through this Google Flow API, taken straight from our release notes.

From [Google Flow API v1: Initial Release](https://useapi.net/blog/251117). Animated from a Nano Banana still passed as `startImage`

.

From [Veo 3.1 Lite and Voice Narration](https://useapi.net/blog/260403). A reference-to-video generation with the `referenceAudio_1: "Zephyr"`

preset adding spoken dialogue.

From [Veo 3.1 Portrait R2V](https://useapi.net/blog/260113). Portrait R2V from a single reference image.

`veo-3.1-quality`

is the highest-fidelity model, `veo-3.1-fast`

is the default balance, and `veo-3.1-lite`

is the cheapest, with `veo-3.1-lite-low-priority`

available to Ultra subscribers at lower scheduling priority. See Supported models above for per-model credits and durations.`email`

`mediaGenerationId.mediaGenerationId`

) as `startImage`

— and optionally `endImage`

for a first→last transition (Veo only, requires `startImage`

). See Image-to-video above.`captchaToken`

and relies on this automatic solving.Visit our [Discord Server](https://discord.gg/w28uK3cnmF) or [Telegram Channel](https://t.me/use_api) for any support questions and concerns.

We regularly post guides and tutorials on the [YouTube Channel](https://www.youtube.com/@midjourneyapi).

Check our [GitHub repo](https://github.com/useapi/google-flow-api) with code examples.