Gemini Omni 1.1 Flash is the version of Google’s Omni video model that developers actually asked for: you can pin the first and the last frame, feed it up to seven reference images, and hand it a short clip to edit — all behind one model id, gemini-omni-1.1-flash. This page answers the three questions people search for before writing a line of code: what it costs per second compared with Google’s own price, which fields select which mode, and what will come back as a 400 so you do not pay to find out.
On the official Gemini API the model is billed in tokens: $17.50 per million video-output tokens, which Google itself converts to roughly $0.10 per second of 720p video (5,792 tokens per second); 1080p and 4K carry more tokens per second and land around $0.15 and $0.30. There is no free tier, and you need a Google Cloud billing account. APIMODELS bills the same model per output second at $0.07 (720p), $0.10 (1080p) and $0.20 (4K) — every tier at least 30% lower — and needs nothing but an API key.
The numbers that matter in production are not on the spec sheet, so we ran them: a 4-second 720p text-to-video clip came back in 57 s, a 6-second first/last-frame clip in 121 s, a 4-second 4K clip in 176 s, and the outputs measure 1280×720, 1920×1080 and 3840×2160 respectively — real 4K, H.264 with an AAC track. Only successful generations are charged.
Both columns are per second of output video. The official column is Google’s own token-to-seconds conversion for 720p; 1080p and 4K are converted at the same token price. The flat-rate row is the one place where we are not always cheaper: when the input is a video, APIMODELS charges a fixed price per job regardless of length, so a source clip shorter than about 7 seconds at 720p costs more here than it would per second on Google.
| Tier | APIMODELS | Official Gemini API (≈) | Difference |
|---|---|---|---|
| 720p, per second | $0.07 | $0.10 | -30% |
| 1080p, per second | $0.10 | $0.15 | -33% |
| 4K, per second | $0.20 | $0.30 | -33% |
| Video input (edit), 720p / 1080p | flat $0.70 per job | $0.10–0.15 × clip seconds | cheaper from ~7 s (720p) / ~5 s (1080p) |
| Video input (edit), 4K | flat $1.05 per job | $0.30 × clip seconds | cheaper from ~4 s |
| 360p | not offered (400) | ≈ $0.03 | — |
| Job | APIMODELS | Official (≈) |
|---|---|---|
| 8 s text-to-video, 720p | $0.56 | $0.80 |
| 6 s first/last frame, 1080p | $0.60 | $0.90 |
| 10 s reference-to-video, 720p | $0.70 | $1.00 |
| 10 s, 4K | $2.00 | $3.00 |
| Edit a 6 s source clip, 720p | $0.70 (flat) | $0.60 |
| Edit a 10 s source clip, 1080p | $0.70 (flat) | $1.50 |
You never pick a mode by name. Send model: "gemini-omni-1.1-flash" and the request body decides: a prompt alone is text-to-video; first_frame_url (optionally with last_frame_url) is keyframe-controlled image-to-video; images (up to 7 public URLs, plus optional audio_ids / character_ids) is reference-to-video; a single video_list entry is video editing, where the output length follows the clip and duration is ignored. Poll the same endpoint with task_id until state is completed or failed.
| Mode | Fields that select it | Duration / resolution | Price basis |
|---|---|---|---|
| Text-to-video | prompt | 4 / 6 / 8 / 10 s · 720p / 1080p / 4k · 16:9 or 9:16 | per second |
| First/last frame | prompt + first_frame_url (+ last_frame_url) | same as above | per second |
| Reference-to-video | prompt + images[] (≤7) (+ audio_ids, character_ids) | same as above | per second |
| Video edit | prompt + video_list[0] = {url, start, ends} (window ≤10 s, source ≤30 s) | output follows the clip; duration ignored | flat $0.70 / $1.05 |
These are rejected at create time, before anything is queued or charged: duration other than 4, 6, 8 or 10; resolution 360p (Google offers it, we do not resell it because our upstream prices it like 720p); last_frame_url without first_frame_url; first/last frames combined with images or a video; more than 7 reference images; more than one clip in video_list. A rejected request costs nothing. A generation that starts and then fails — including one blocked by Google’s content policy — is refunded automatically.
Six production calls on launch day (2026-09-04) through the public API, not a benchmark rig. Expect 4K to take roughly three times as long as 720p; poll every 10 seconds rather than hammering the endpoint.
| Job | Wall time | Output |
|---|---|---|
| Text-to-video, 4 s, 720p | 57 s | 1280×720, H.264 + AAC |
| First/last frame, 6 s, 720p | 121 s | 1280×720; frame 2 s = the first frame you passed |
| Reference-to-video, 2 images, 4 s, 9:16 720p | 67 s | 720×1280 |
| Text-to-video, 4 s, 1080p | 77 s | 1920×1080 |
| Text-to-video, 4 s, 4K | 176 s | 3840×2160 |
| Video edit of a 6 s clip, 720p | 99 s | 6.0 s output following the source |
Sign up with any common email, create an API key, and call the endpoint below — the same key works for the rest of the catalog (Seedance, Kling, GPT Image, Claude, Gemini text). Pay with Stripe, PayPal or Alipay; the site is reachable from mainland China. The signup credit is $0.10, which does not cover a full clip — the smallest paid clip is a 4-second 720p job at $0.28 — so plan on a $10 top-up for real testing.
cURL
# Text-to-video. Same endpoint for every mode; the body decides.
curl -X POST https://api.apimodels.app/v1/video/generations \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gemini-omni-1.1-flash",
"prompt": "a paper boat drifting down a rain-filled gutter, low angle, soft morning light",
"duration": "8",
"resolution": "720p",
"aspect_ratio": "16:9"
}'
# -> { "data": { "taskId": "..." } } 8 s x $0.07 = $0.56, charged only on success
# First/last frame: add first_frame_url (+ last_frame_url); nothing else changes.
# "first_frame_url": "https://example.com/first.jpg",
# "last_frame_url": "https://example.com/last.jpg"
# Poll until state is "completed" or "failed"
curl "https://api.apimodels.app/v1/video/generations?task_id=TASK_ID" \
-H "Authorization: Bearer YOUR_API_KEY"Python
import requests, time
H = {"Authorization": "Bearer YOUR_API_KEY", "Content-Type": "application/json"}
ENDPOINT = "https://api.apimodels.app/v1/video/generations"
# First/last-frame image-to-video: the clip starts on first_frame_url and
# lands on last_frame_url. 6 s x 1080p x $0.10 = $0.60.
task_id = requests.post(ENDPOINT, headers=H, json={
"model": "gemini-omni-1.1-flash",
"prompt": "the camera slowly pushes in as the clouds roll over the ridge",
"first_frame_url": "https://example.com/first.jpg",
"last_frame_url": "https://example.com/last.jpg",
"duration": "6", # "4" / "6" / "8" / "10" -- anything else is a 400
"resolution": "1080p", # "720p" / "1080p" / "4k" -- 360p is a 400
}).json()["data"]["taskId"]
while True:
data = requests.get(ENDPOINT, headers=H, params={"task_id": task_id}).json()["data"]
if data["state"] == "completed":
print(data["resultUrls"][0]); break
if data["state"] == "failed":
print(data["failMsg"]); break # failed jobs are refunded
time.sleep(10)On APIMODELS, $0.07 per second at 720p, $0.10 at 1080p and $0.20 at 4K, billed on the output length you asked for (4, 6, 8 or 10 seconds); an 8-second 720p clip is $0.56. Jobs that take a video as input are a flat $0.70 (720p/1080p) or $1.05 (4K). On Google’s official Gemini API the model bills $17.50 per million video-output tokens, which Google converts to about $0.10 per second at 720p — roughly $0.15 at 1080p and $0.30 at 4K — with no free tier. Only successful generations are charged here.
The model id is gemini-omni-1.1-flash. POST https://api.apimodels.app/v1/video/generations with an Authorization: Bearer header and a JSON body; you get back data.taskId. Poll GET https://api.apimodels.app/v1/video/generations?task_id=… until data.state is completed (then data.resultUrls[0] is the mp4) or failed (data.failMsg says why, and the charge is reversed). The same id and endpoint serve all four modes.
Pass first_frame_url with a public image URL and, optionally, last_frame_url; the clip opens on the first image and resolves onto the last one, with the prompt describing the motion in between. last_frame_url on its own is rejected (400), and keyframes cannot be combined with images or video_list in the same request. In our test a 6-second 720p keyframe job returned in 121 seconds and frame 2 s was verifiably the first image we sent.
Yes. Put one clip in video_list as {url, start, ends} — the window can be at most 10 seconds and the source file at most 30 — and describe the change in the prompt (“make it snow” kept the landscape, camera and light in our test). The output length follows the clip and duration is ignored. It is a flat $0.70 at 720p/1080p or $1.05 at 4K per job, so it is cheaper than the official per-second rate from about 7 seconds of source at 720p, and more expensive below that.
360p draft output (Google sells it at about $0.03/s; our upstream charges 720p prices for it, so we return a 400 rather than silently upgrading you); clip lengths other than 4/6/8/10 seconds; more than 7 reference images; more than one source clip; and scene extension beyond the 10-second clip window. If you need 30-second single-pass clips or extension, use Seedance 2.5 instead.
It is Google’s gemini-omni-1.1-flash served through a partner channel, which is why the output resolutions, the keyframe behaviour and the audio track match what the official API returns; Google’s invisible SynthID watermark is part of the model and applies here too. You do not need a Google account, a Cloud project or a billing setup — an APIMODELS API key is enough, and you can pay by Stripe, PayPal or Alipay.
