Google Gemini Omni: What It Does and API Options (2026)

Google Gemini Omni is a family of Google generative models that accepts text, images, audio and video as input and returns video: either a brand-new clip or an edited version of footage you supplied. Google announced it at Google I/O on May 19, 2026, and the faster Gemini Omni Flash tier has since received a 1.1 update.

This post explains what the model does, how its inputs and editing loop work, where you can use it, and what it means for developers who want the same kind of results inside their own apps. If you searched for a Gemini Omni API, skip to the section on building an Omni-style workflow: it has working code you can run today.

What is Google Gemini Omni?

Google Gemini Omni is Google’s attempt to collapse several video tools into one model family. Earlier video generators mostly did one job: you typed a prompt, or uploaded a photo, and got a short clip back. Omni is multimodal, meaning it reads several kinds of input in the same request, and its output is always video.

That gives it two broad modes:

• Generation. Start from text, a still image, an audio track, or a combination, and get a new clip. A product photo plus a line of description becomes a short ad; a voice recording plus a character image becomes a talking scene.
• Editing. Start from an existing video and describe what should change. Swap the background, alter the lighting, restyle the whole clip, or change an object, all in plain language.

It sits under the Gemini brand, the name Google uses for both its chatbot (originally called Bard) and its model families. Coverage at launch framed Omni as Google moving into the space left open after OpenAI discontinued Sora, its consumer text-to-video app. Whatever the competitive story, the practical point is simpler: Google now has one model family that treats every input type as a valid starting point for video.

How does Gemini Omni work?

Google has not published a full technical breakdown, so treat any detailed architecture claim you read elsewhere with caution. What matters for users is the behaviour, which is consistent across the reports and hands-on tests published since launch.

Inputs: anything you can describe or show

Google Gemini Omni accepts four input types, and you can mix them:

• Text: the scene, camera movement, mood and dialogue.
• Images: a start frame, a character reference, a product shot or a style reference.
• Audio: a voice line or soundtrack the video should follow.
• Video: existing footage to edit or extend, including live or phone-recorded clips.

Outputs: video with sound

The Flash tier generates native audio, meaning speech and sound effects are produced alongside the picture in one pass rather than added afterwards by a separate tool. That matters because lip movement and on-screen events line up with the sound without manual syncing.

Editing by conversation

The part that feels new is the follow-up loop. After a first generation, you refine the clip with follow-up prompts such as “make it dusk”, “remove the second car” or “slow the camera down”. Each request builds on the previous result instead of starting over. In practice this is closer to working with an editor than rolling dice on a generator.

Under the hood, most current video generators are diffusion models: they start from random noise and remove it step by step until a coherent sequence of frames appears, guided by your inputs. Whether Omni follows exactly that recipe is Google’s business, but the trade-offs are the same ones you see across the category: longer and higher-resolution clips cost more compute, and fine detail like hands and text is where errors show up first.

Gemini Omni Flash and the 1.1 update

Like other Gemini model families, Omni comes in tiers. Gemini Omni Flash is the faster one. In Google’s naming, “Flash” models trade some top-end quality for speed and lower cost per generation, which is usually the right trade for drafts, social clips and anything you will iterate on several times.

Omni Flash covers the main jobs most people want:

• Text-to-video: describe a scene, get a clip.
• Image-to-video: animate a still image as the first frame.
• Native speech and sound effects generated with the video.
• Prompt-based editing of existing clips.

Gemini Omni 1.1 Flash is the newest update to that tier. Early hands-on testers focused on the same areas they test for every video model: motion quality, how well characters stay consistent from frame to frame, how faithfully edits respect the parts of the clip you did not ask to change, and how natural the generated speech sounds. If you are choosing between tiers, a sensible rule is to draft in Flash and only move up when a specific shot needs more fidelity.

How to access Google Gemini Omni (app, free use, API and pricing)

This is where most searchers get stuck, because “Google Omni” is not a single app you download. Access to Google Gemini Omni runs through several routes.

Google’s own apps

Google rolled Omni capabilities into its creative tools, including Flow, its AI filmmaking product, which gained dedicated apps and Omni upgrades at the same I/O event. For most non-developers, Google’s apps are the simplest way to try it: sign in, upload or describe, and generate.

Third-party creative platforms

Omni Flash is also offered inside some third-party creative tools, such as Krea, which added text-to-video, image-to-video and prompt-based editing with it. These platforms wrap the model in their own interface and billing.

Is Gemini Omni free?

Partly, depending on where you use it. Google decides which plans include Omni and how many generations each one allows, and those limits change. Some third-party platforms offer trial credits. Heavy or automated use is paid, because video is the most compute-hungry output any AI model produces.

Gemini Omni API and pricing

Google controls developer access to Omni, so check Google’s developer documentation for current availability, regions, rate limits and prices. Pricing for video models is typically set per second of output and varies by tier, resolution and whether audio is included, so a single headline number rarely tells you what a real project costs.

To be clear about our own catalog: Google Gemini Omni is not available on Unicorn API. What is available are models that cover the same jobs (start frames, image-to-video, video with generated audio, and video-referenced generation) under one key, with the exact price shown before you run anything. The rest of this post shows how to put them together.

What Gemini Omni is good at, and where it falls short

Any-input-to-video is most useful when your source material already exists in some form. Strong use cases:

• Product and ad clips from existing product photography.
• Talking scenes from a character image plus a voice line.
• Quick fixes to real footage: changing the time of day, removing a distracting object, restyling a clip to match a brand look.
• Storyboards and previsualisation, where speed matters more than perfect detail.
• Social content in vertical formats, iterated through follow-up prompts.

The limits are the ones shared by every current video model, and Google Gemini Omni is no exception:

• Short clips. Generations are measured in seconds. Longer pieces are assembled from multiple shots.
• Consistency drift. Faces, logos and small text can change between shots or even within one.
• Edits can leak. Asking to change one object sometimes alters nearby details you wanted kept.
• Cost scales with length and resolution. Iterating at full quality gets expensive fast.
• Platform lock-in. If you build on one provider’s model, you inherit its availability, content rules and price changes.

That last point is the main reason developers look at multi-model setups: when one model is busy, restricted or priced out of your budget, you want to swap it with a one-line change.

Building a Google Gemini Omni-style workflow with an API

You can reproduce the core Omni workflow by chaining specialised models: an image model for the first frame, then a video model that accepts images, reference video and audio settings. Here is how the jobs map to models in the Unicorn API catalog.

Omni-style job	Model on Unicorn API	Relevant inputs	Price (credits)
Create a start frame or reference image	Nano Banana 2 Lite (Google)	prompt, up to 10 ref_images, aspect_ratio	4 per image
Start frame with legible text (signs, labels)	GPT Image 1.5	prompt, quality, up to 4 ref_images	3 low, 4 medium, 22 high
Image-to-video with generated audio	PixVerse V6 Max Image To Video	image_urls, quality, duration, generate_audio_switch	12 per second at 720p with audio
Video from reference images or reference video	Kling 4.0 Reference To Video	image_urls, video_urls, voices, elements, keep_original_sound	17 per second at 720p with video_urls
Control first and last frame	Kling 4.0 Keyframe To Video	first_frame_url, last_frame_url, keyframe_urls	28.5 per second at 720p
Cheap animation drafts	Grok Imagine Video 1.5	image, duration 1-15 s, resolution	22.5 for 5 s at 720p (billed as 23)
Longer clips, text or image start	Grok Imagine Video 1.0	prompt or image, 6-30 s	27 for 6 s at 720p

Credits cost $0.01 each on monthly plans (Starter $25, Creator $50, Studio $100, Pro $200 per month) and $0.015 as top-ups that never expire. See pricing for details.

Worked example: product photo to a 5-second clip with sound

The script below does three things: checks the price of the video job before running it, generates a 16:9 start frame with Nano Banana 2 Lite, then animates it with PixVerse V6 Max at 720p with audio on. Media models run as jobs: you POST to /v1/jobs, then poll GET /v1/jobs/{id} until the status is succeeded and read outputs[0].url. Create a key on the API keys page and export it as UNICORN_API_KEY.

import os
import time
import requests

BASE = "https://api.unicornapi.net"
HEADERS = {
    "Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}",
    "Content-Type": "application/json",
}


def price(model, input_):
    """Ask for the exact cost before running. Same body as a job."""
    r = requests.post(f"{BASE}/v1/models/price", headers=HEADERS,
                      json={"model": model, "input": input_})
    r.raise_for_status()
    return r.json()


def run_job(model, input_, timeout=900):
    """Submit a media job and poll until it succeeds."""
    r = requests.post(f"{BASE}/v1/jobs", headers=HEADERS,
                      json={"model": model, "input": input_})
    r.raise_for_status()
    job = r.json()
    deadline = time.time() + timeout
    while job["status"] != "succeeded":
        if job["status"] in ("failed", "error", "canceled"):
            raise RuntimeError(f"Job {job['id']} ended as {job['status']}")
        if time.time() > deadline:
            raise TimeoutError(f"Job {job['id']} still running")
        time.sleep(5)
        g = requests.get(f"{BASE}/v1/jobs/{job['id']}", headers=HEADERS)
        g.raise_for_status()
        job = g.json()
    return job["outputs"][0]["url"]


# 1. Start frame (4 credits)
frame_url = run_job("nano-banana-2-lite", {
    "prompt": ("A matte black ceramic coffee mug on a wooden cafe table, "
               "morning window light, steam rising, shallow depth of field"),
    "aspect_ratio": "16:9",
})
print("Frame:", frame_url)

# 2. Video with generated audio (12 credits/s at 720p with audio)
video_input = {
    "prompt": ("Slow push-in on the mug as steam curls upward, soft cafe "
               "chatter and the clink of a spoon in the background"),
    "image_urls": [frame_url],
    "quality": "720p",
    "duration": 5,
    "generate_audio_switch": True,
}
print("Video price:", price("pixverse-v6-max-image-to-video", video_input))

video_url = run_job("pixverse-v6-max-image-to-video", video_input)
print("Video:", video_url)

The cost is easy to reason about: 4 credits for the frame plus 12 × 5 = 60 credits for the clip, so 64 credits in total. That is $0.64 on a monthly plan or $0.96 with top-up credits. If you generate three candidate frames first (set "n": 3, 12 credits) and animate the best one, the run costs 72 credits.

Editing from a reference video

For the “start from existing footage” side of Omni, Kling 4.0 Reference To Video accepts video_urls, and the per-second price drops when you supply them: 17 credits per second at 720p versus 28.5 without. A 5-second run with a reference clip is 85 credits.

curl -X POST https://api.unicornapi.net/v1/jobs \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kling-4.0-reference-to-video",
    "input": {
      "prompt": "Same street and camera move, but at dusk with wet pavement and neon reflections",
      "video_urls": ["https://example.com/my-street-clip.mp4"],
      "resolution": "720p",
      "duration": 5,
      "keep_original_sound": true
    }
  }'

# Then poll until status is "succeeded" and read outputs[0].url:
curl https://api.unicornapi.net/v1/jobs/JOB_ID \
  -H "Authorization: Bearer $UNICORN_API_KEY"

To recreate the conversational follow-up loop, keep a short history of what the user asked for and use a chat model to rewrite it into one clean prompt per run. GPT 6.1 Terra works through the OpenAI-compatible POST /v1/chat/completions endpoint at 60 credits per million input tokens and 300 per million output tokens, so a prompt rewrite costs a fraction of a credit. Full request details are in the API documentation, and if you work in Cursor or Claude Code, the MCP setup lets your agent call these models directly.

Common mistakes with any-input-to-video models

Whether you use Google Gemini Omni or a chain of models, the same errors waste the most time and money.

1. Iterating at final resolution. Draft at low resolution and short duration, then re-run the winning prompt at 720p or 1080p. On Grok Imagine Video 1.5, 5 seconds at 480p is 12 credits versus 40 at 1080p.
2. Skipping the start frame. Text-only video gives the model too much freedom. A good first frame fixes composition, colour and the subject’s look, and an image costs a few credits instead of a whole clip.
3. Vague edit requests. “Make it better” produces random changes. Name the object, the change and what must stay the same.
4. Asking for too much motion in one shot. One camera move and one main action per clip. Build sequences from several short shots.
5. Ignoring audio settings. Generated audio adds cost (on PixVerse V6 Max, 12 versus 8.8 credits per second at 720p). Turn it off for clips that will get music in the edit.
6. Not checking the price first. Video prices depend on duration, resolution and options. Call the price endpoint before batch jobs, not after.
7. Relying on generated text in the frame. If a sign or label must be legible, create the start frame with a model known for text, such as GPT Image 1.5, and keep the camera move gentle so the text survives.

Google Gemini Omni or a multi-model API: which should you use?

Use Google Gemini Omni if you want one consistent interface for generating and editing video, you are happy working inside Google’s apps or partner tools, and the follow-up editing loop is central to how you work. Its strength is that everything, from inputs and audio to edits, lives in one model family that understands all of it together.

Use a multi-model API when you are building a product rather than making a single video. You get to pick the cheapest model that meets each shot’s quality bar, swap providers when one is busy or changes its rules, see the exact cost of every request before it runs, and pay one bill. The trade-off is that you own the orchestration: start frames, prompt rewriting and polling are your code, not a single chat box.

Many teams end up doing both: experimenting by hand in a tool like Omni, then moving the workflow that works into an API pipeline they control. If you want to try the image side first in the browser, the image playground runs the same models without code, and our post on Nano Banana 2 Lite covers start-frame prompts in more depth.