How to Make Gemini Omni Flash Videos Longer Than 10 Seconds

Q: Does conversational editing make a video longer?

No. Passing previous_interaction_id edits the existing clip — same length, refined content — and the session context holds for only about three sequential turns. It's for polishing a shot, not extending it.

Quick Answer

Gemini Omni Flash generates 3–10 seconds per request, hard cap — in the API public preview and on the consumer surfaces alike. There is no length parameter to raise, prompting "make a 30-second video" doesn't work, and scene extension is not supported yet (Google says longer durations are coming, without a date). But creators are already shipping 30–60-second videos with it. The method is the one filmmakers have always used: you don't shoot a scene, you shoot shots. Plan your video as a sequence of ≤10-second clips, keep continuity between them with a last-frame chain — the final frame of clip N becomes the image input for clip N+1 — and assemble the sequence in an editor. This guide covers the three ways to do that today (two need no code at all), where each one breaks, and what a 60-second video actually costs at $0.10 per second of output.

Key Takeaways

The 10-second cap is per generation, not per video. Every long "Omni Flash video" you've seen is a chain of clips.
Last-frame chaining is the continuity workhorse: export the final frame of one clip, use it as the starting image of the next. It works in a browser studio and in the API, and it's the only method with no length ceiling.
Conversational editing does not extend length. The Interactions API edits the existing clip and keeps session context for only about three sequential turns — it refines, it doesn't append.
Don't waste money prompting for longer clips. Requests beyond 10 seconds don't produce them; you just pay for another ≤10s render.
Budget ~$6 per raw minute via the API (6 × 10s at $0.10/second) — realistically $10–15 with retakes, before editing time.
No code required: methods 1 and 2 work entirely in a browser workflow — plan shots, generate, chain frames, stitch.

Why every clip stops at 10 seconds

The public preview of the Gemini Omni Flash API (model ID gemini-omni-flash-preview, live since June 30, 2026) generates 3–10-second clips at 720p, billed at $0.10 per second of output. The same per-generation cap applies in the Gemini app, Google Flow, and YouTube Shorts. Two related limits matter for length specifically, straight from Google's docs:

Scene extension is not supported. You cannot ask the model to continue an existing video where it left off.
Video references are capped at 3 seconds, and reasoning across multiple input videos isn't supported — so you can't feed a finished 10-second clip back in and say "keep going."

Google's launch post says longer durations are planned. Until they ship, length is a workflow problem, not a model setting — and the workflow is well understood.

Method 1: Storyboard and stitch (no code)

The professional default. Instead of fighting for one long take, write your video as a shot list where every shot fits inside 10 seconds:

Script the beats first. A 45-second product video is typically 5–6 shots: hook, problem, product reveal, feature close-up, social proof, call to action.
Write one prompt per shot, keeping the style block identical across all of them — same lighting description, same camera vocabulary, same color grade. Our prompt templates are structured exactly for this.
Generate each shot separately, retaking only the shots that miss.
Assemble in any editor — CapCut, Premiere, DaVinci Resolve, or YouTube Create. Hard cuts between shots read as intentional filmmaking; nobody watching a cut expects one continuous take.

This is also how you sidestep the cap's real cost: when shot 4 of 6 fails, you re-roll one $1.00 clip, not a whole minute. The full planning workflow — hooks, pacing, stitching for 9:16 — is in our YouTube Shorts playbook.

Where it breaks: across hard cuts, the model has no memory. If the same character or product must appear in every shot, you need reference discipline — which is Method 2's job.

Method 2: Last-frame chaining (no code)

When you need continuity — the same subject, the same scene, motion that flows across the 10-second boundary — chain the clips:

Generate clip 1 (up to 10 seconds).
Export its final frame as an image (any video player or editor can do this; in a browser studio it's a right-click).
Start clip 2 as image-to-video with that frame as the starting image, plus a prompt describing what happens next: "continuing the same shot, she turns from the window and walks toward the door, same lighting, same color grade."
Repeat. Stitch the clips end-to-end — the seams land on identical frames, so the joins are nearly invisible.

Because each link starts from your exact previous frame, the subject, composition, and grade are locked by the image rather than re-invented from text. That's the same property that makes image-to-video the most reliable path to on-brand video — chaining just applies it repeatedly.

Three craft rules that decide whether the seam shows:

Cut on stillness, not motion. End each clip on a natural pause (a look, a landing, a held pose). A frame grabbed mid-motion-blur makes a mushy start for the next clip.
Restate the style block every link. The image carries composition; the prompt still controls motion and mood. Drop the style text and the grade drifts by clip 3.
Carry a character reference alongside the frame if a face must survive many links — technique in the consistent characters guide.

Where it breaks: audio. Each clip generates its own synchronized audio, so a chained sequence has audio seams even when the picture flows. For anything dialogue- or music-led, mute the generated audio and lay a continuous voiceover or music bed over the stitched cut — standard practice for Shorts anyway.

Method 3: Chaining via the API (code)

The programmatic version of Method 2, for anyone building length into a product. Each link is an image-to-video call whose input image is the last frame of the previous output — extract it with ffmpeg -sseof -0.05 -i clip1.mp4 -frames:v 1 last.jpg, then pass it as the image part of the next request. Setup, parameters, and working Python/JavaScript/curl for image-to-video calls are in the API tutorial.

One thing the API tempts you to try that doesn't work as an extender: previous_interaction_id. That's the conversational-editing mechanism — it refines the existing clip (change the jacket, warm the light) with scene context carried over, and Google notes the session holds for roughly three sequential edits. It's the model's best feature for iterating on a shot, but every turn re-renders the same ≤10 seconds; none of them appends an eleventh. Use interactions to perfect each link, and last-frame chaining to add the next one.

What a 60-second video actually costs

At $0.10 per second of output, length is a budget line, not just a technical limit:

Final length	Clips (10s)	Raw API cost	Realistic (≈2× with retakes)
20 seconds	2	$2.00	~$4
30 seconds	3	$3.00	~$6
60 seconds	6	$6.00	~$12

Two ways to keep the multiplier near 1×: lock look-and-feel on cheap stills before rendering motion (the Nano Banana 2 Lite → Omni Flash pipeline exists for exactly this), and remember that conversational-edit turns bill like generations — three edits on a 10-second clip is $4.00 total, not $1.00.

If you'd rather not manage API keys, quota panels, and ffmpeg: Omni Flash runs this whole loop — prompt templates, image-to-video for frame chaining, per-clip credits — in the browser. It's an independent platform (not affiliated with Google) that generates on available advanced models such as Veo 3.1 with the same shot-based workflow, so your storyboards and chains port straight across model generations. Credit packs map one-to-one onto the clips-per-video math above.

FAQ

Can Gemini Omni Flash generate videos longer than 10 seconds?

Not in a single generation — 3–10 seconds per request is a hard cap in the public preview and on consumer surfaces. Longer videos are made by generating multiple clips and joining them, using storyboard stitching or last-frame chaining. Google has said longer durations are planned but hasn't committed to a date.

Does conversational editing make a video longer?

No. Passing previous_interaction_id edits the existing clip — same length, refined content — and the session context holds for only about three sequential turns. It's for polishing a shot, not extending it.

Can I feed a finished clip back in and ask it to continue?

No — scene extension isn't supported, and video references are capped at 3 seconds with no reasoning across multiple input videos. The supported continuity path is a still image: the last frame of your previous clip as the image input for the next one.

Try the Omni Flash studio → — shot-based generation and image-to-video chaining in the browser, no API key required.
Read: Image to video with Gemini Omni Flash → — the technique last-frame chaining is built on.
Read: Gemini Omni Flash API tutorial → — model ID, pricing, and working code for programmatic chaining.
Read: The YouTube Shorts playbook → — planning, stitching, and audio for short-form.
Read: Consistent characters guide → — keeping a face stable across a long chain.
Compare credit packs → — budget clips-per-video without managing preview quotas.