MODEL IDbfl:flux@3-video

live

FLUX 3 Video

by Black Forest LabsAugust 4, 2026

FLUX 3 Video is Black Forest Labs' multimodal foundation model for video generation with synchronized audio. It generates clips from 5 to 20 seconds across text-to-video, image-to-video, and video-to-video modes on one architecture, with keyframe control to pin an opening image or interpolate motion across pinned frames, chained continuations for arcs beyond 20 seconds, multi-shot sequences with hard cuts inside one generation, and native multilingual dialogue. A draft mode returns a fast low-resolution preview and a cache that a follow-up call enhances at full quality, tightening iteration loops. Style range spans candid camcorder footage, animation, motion design, and cinematic photoreal, character consistency holds across scenes within one generation, and in-video typography renders cleanly for titles and animated designs.

Video continuation with FLUX 3

How to continue a source clip from its final frames with FLUX 3's video input: single-clip continuation, chaining across multiple generations, deliberate source design, and recovering shots that didn't land.

Introduction

inputs.video continues a source clip from its final frames. FLUX 3 opens the new clip on the exact frame the source ended on, then generates forward from there in the same framing, lighting, and audio register the source established.

The pair below shows the pattern. The source clip tracks alongside a red racing car in the final straight of a circuit and lands on the exact moment it crosses the finish line at full speed. The continuation opens on that exact frame, then the car decelerates as the driver raises a victory salute above the cockpit.

Source video ending at the finish line

An 8-second wide side-tracking shot of a Formula-style single-seat racing car in bright red livery with white sponsor markings, driving hard along the final straight of a European circuit at high speed. Warm afternoon light, spectator grandstands blurred behind trackside barriers, a checkered flag visible in the last two seconds waving above the finish line. The car crosses the finish line on the final frame, still at full speed, front wing sharp in focus. Camera tracks alongside at ground level. Audio: the sustained high-pitched scream of the engine at full throttle, the doppler shift as the car passes, the roar of a distant crowd through the grandstands, the muffled whoosh of tires on tarmac. No music, no on-screen text.

Continuation output

Continue the reference video from its final frames. The racing car decelerates smoothly over the next three seconds, engine note dropping from a full-throttle scream to a burble as the driver releases the throttle, then coasts along the pit straight toward the paddock. The driver, in a red racing suit and full helmet, raises a gloved fist above the cockpit in a slow victory salute as the car rolls past camera. Camera continues tracking alongside at ground level, warm afternoon light unchanged. Audio: the engine note dropping from full-throttle scream to idle burble, the crowd roar swelling to a peak as the fist goes up, then softening as the car passes. No music, no on-screen text.

FLUX 3 held the car's identity, the track, the camera position, and the engine and crowd audio because those were carried forward from the source's final frames. The prompt only had to describe the deceleration and the salute. This guide covers the single-continuation pattern, how to design sources that continue cleanly, chaining continuations for longer arcs, and recovering shots that didn't finish where you wanted.

What carries forward from the source's final frames: framing, camera position, lighting temperature, ambient audio layers, the subject's position and physical state, and environmental physics that are still in play (wind, water, fire, motion that hasn't resolved). The prompt shapes what happens next. Every other detail comes from the source. When something reads wrong in the continuation, check which of those the source is actually establishing. Whatever the source doesn't anchor, the model has to invent.

Request shape

Continuation is a videoInference call with a source clip in inputs.video. Duration, dimensions, and audio follow the prompting guide defaults.

import { createClient } from '@runware/sdk'

const client = await createClient({ apiKey: process.env.RUNWARE_API_KEY })
await client.connect()

const [result] = await client.run({
  model: 'bfl:flux@3-video',
  positivePrompt: 'Continue the reference video from its final frames. The racing car decelerates smoothly over the next three seconds, engine note dropping from a full-throttle scream to a burble as the driver releases the throttle, then coasts along the pit straight toward the paddock. The driver, in a red racing suit and full helmet, raises a gloved fist above the cockpit in a slow victory salute as the car rolls past camera. Camera continues tracking alongside at ground level, warm afternoon light unchanged. Audio: the engine note dropping from full-throttle scream to idle burble, the crowd roar swelling to a peak as the fist goes up, then softening as the car passes. No music, no on-screen text.',
  inputs: {
    video: 'https://vm.runware.ai/video/os/a14d18/ws/2/vi/aabb1122-3344-5566-7788-99aabbccddee.mp4'
  },
  resolution: '720p',
  duration: 8
})

import asyncio
import os

from runware import Runware


async def main():
    async with Runware(api_key=os.environ["RUNWARE_API_KEY"]) as client:
        results = await client.run({
            "model": "bfl:flux@3-video",
            "positivePrompt": "Continue the reference video from its final frames. The racing car decelerates smoothly over the next three seconds, engine note dropping from a full-throttle scream to a burble as the driver releases the throttle, then coasts along the pit straight toward the paddock. The driver, in a red racing suit and full helmet, raises a gloved fist above the cockpit in a slow victory salute as the car rolls past camera. Camera continues tracking alongside at ground level, warm afternoon light unchanged. Audio: the engine note dropping from full-throttle scream to idle burble, the crowd roar swelling to a peak as the fist goes up, then softening as the car passes. No music, no on-screen text.",
            "inputs": {
                "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/aabb1122-3344-5566-7788-99aabbccddee.mp4"
            },
            "resolution": "720p",
            "duration": 8
        })


asyncio.run(main())

curl https://api.runware.ai/v1 \
  -H "Authorization: Bearer $RUNWARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[
    {
      "taskType": "videoInference",
      "taskUUID": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
      "model": "bfl:flux@3-video",
      "positivePrompt": "Continue the reference video from its final frames. The racing car decelerates smoothly over the next three seconds, engine note dropping from a full-throttle scream to a burble as the driver releases the throttle, then coasts along the pit straight toward the paddock. The driver, in a red racing suit and full helmet, raises a gloved fist above the cockpit in a slow victory salute as the car rolls past camera. Camera continues tracking alongside at ground level, warm afternoon light unchanged. Audio: the engine note dropping from full-throttle scream to idle burble, the crowd roar swelling to a peak as the fist goes up, then softening as the car passes. No music, no on-screen text.",
      "inputs": {
        "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/aabb1122-3344-5566-7788-99aabbccddee.mp4"
      },
      "resolution": "720p",
      "duration": 8
    }
  ]'

runware run bfl:flux@3-video \
  positivePrompt="Continue the reference video from its final frames. The racing car decelerates smoothly over the next three seconds, engine note dropping from a full-throttle scream to a burble as the driver releases the throttle, then coasts along the pit straight toward the paddock. The driver, in a red racing suit and full helmet, raises a gloved fist above the cockpit in a slow victory salute as the car rolls past camera. Camera continues tracking alongside at ground level, warm afternoon light unchanged. Audio: the engine note dropping from full-throttle scream to idle burble, the crowd roar swelling to a peak as the fist goes up, then softening as the car passes. No music, no on-screen text." \
  inputs.video=https://vm.runware.ai/video/os/a14d18/ws/2/vi/aabb1122-3344-5566-7788-99aabbccddee.mp4 \
  resolution=720p \
  duration=8

{
  "taskType": "videoInference",
  "taskUUID": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "model": "bfl:flux@3-video",
  "positivePrompt": "Continue the reference video from its final frames. The racing car decelerates smoothly over the next three seconds, engine note dropping from a full-throttle scream to a burble as the driver releases the throttle, then coasts along the pit straight toward the paddock. The driver, in a red racing suit and full helmet, raises a gloved fist above the cockpit in a slow victory salute as the car rolls past camera. Camera continues tracking alongside at ground level, warm afternoon light unchanged. Audio: the engine note dropping from full-throttle scream to idle burble, the crowd roar swelling to a peak as the fist goes up, then softening as the car passes. No music, no on-screen text.",
  "inputs": {
    "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/aabb1122-3344-5566-7788-99aabbccddee.mp4"
  },
  "resolution": "720p",
  "duration": 8
}

Response

[
  {
    "taskType": "videoInference",
    "taskUUID": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "videoUUID": "b2c3d4e5-f6a7-8901-bcde-f12345678901",
    "videoURL": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/b2c3d4e5-f6a7-8901-bcde-f12345678901.mp4"
  }
]

Prompts for video open with a framing cue like "continue the reference video from its final frames" or "picking up from the end of the reference video". That framing tells the model to build forward rather than to interpret the source as a general reference. The prompt then describes what happens next, in the same visual and sonic register the source established.

inputs.video and inputs.frameImages are mutually exclusive per request. If you need image-driven inputs instead, see the keyframes guide.

Deliberate source endings

Continuation quality is set as much by how the source ends as by what the continuation prompt says. FLUX 3 opens the new clip on the source's final frame, so anything left unresolved at that frame is what the model has to guess through.

Sources that continue cleanly share four properties:

Motion resolves. The subject comes to rest or reaches a stable pose. Mid-gesture endings force the model to invent how the motion completes, and small inventions read as stutters at the join.
The camera is at rest. A dolly or pan that's still moving on the last frame gets interpreted as ongoing camera motion, whether the continuation prompt asks for it or not. Land the camera before ending the source.
Audio has a clean beat. A source that ends with a spoken word half-formed carries the vocal cutoff into the continuation. Trim to a natural pause or breath.
The subject is positioned to do the next thing. If the continuation prompt is "she picks up the letter", the source should end with her hand near the letter, not across the room.

The pair below is a clean example. The source ends with a writer finishing a note and setting the pen down beside the paper: motion resolved, camera at rest, subject positioned exactly where the next beat begins. The continuation picks up her hand, lifts the note, folds it, and seals it into an envelope.

Source ending clean: motion resolved, hand at rest

A 7-second locked-off overhead shot of a writer's hand finishing a short handwritten note on cream paper at a warm walnut desk. The pen makes the last stroke, lifts off the page, and comes to rest beside the folded corner of the paper. The hand relaxes and rests flat on the desk in the final second. Warm afternoon light from the upper left, a small brass paperweight in the top right of frame. Audio: the soft scratch of pen on paper, a quiet room tone, the faintest sigh as the pen sets down. No music, no on-screen text.

Continuation lands cleanly at the join

Continue the reference video from its final frames. The writer's hand picks up the note, folds it in half once and then in half again, slides it into a small cream envelope beside the paperweight, and presses the flap closed with her thumb. The camera stays locked overhead. Audio: the crisp fold of the paper on each crease, the soft slide of paper against the envelope, a satisfied breath, the room tone continuing underneath. No music, no on-screen text.

The join is invisible because the source did the work: the pen's final position is where the hand starts, the room tone loops through the cut without a break, and the camera doesn't have to reconcile a moving frame into a stationary one.

For continuations you're planning in advance, generate the source with the resting state you need for the continuation as its explicit final frame. Prompts like "the camera comes to rest on X as the last frame" or "the subject settles into Y as the closing beat" pay off downstream when you continue the shot.

Chaining continuations for longer sequences

A single request tops out at 20 seconds. When the piece needs more runtime, chain generations: use the output of one continuation as the source for the next. The three clips below run as one 15-second craft narrative (heating iron, hammering it on the anvil, quenching it in water) assembled from three FLUX 3 calls where each continuation used the previous clip as its video input.

Source: heating

A 5-second interior of a warmly-lit traditional blacksmith's forge at dusk. A blacksmith in a heavy leather apron and thick gloves holds a long iron bar in the flames of the coal forge, the tip of the bar glowing bright orange. The camera holds locked at a mid-close angle on the fire and the bar. Audio: the deep hiss and crackle of the coal fire, the low whirr of the bellows, quiet ambient forge tone. No music, no on-screen text.

Continuation A: shaping

Continue the reference video from its final frames. The blacksmith withdraws the glowing iron bar from the flames and moves it swiftly onto the anvil, then strikes it firmly with a hammer, sending a spray of bright orange sparks upward into the dim forge air. Three clean strikes, the iron ringing on each impact. Audio: the sharp metallic ring of hammer on iron on each strike, the crackle of falling sparks, the fire still burning in the background. No music, no on-screen text.

Continuation B: quenching

Continue the reference video from its final frames. The blacksmith lifts the still-hot iron bar from the anvil and plunges it into a barrel of water beside the anvil, sending a large burst of white steam hissing up into the forge air. The camera stays locked on the barrel and the steam. Audio: the sharp initial hiss of the quench, the deeper rolling boil as the metal cools, wisps of steam continuing to rise, the fire still burning quietly in the background. No music, no on-screen text.

Each continuation carried three things forward from its source: the framing, the audio layers, and the physical state the previous clip ended on (the iron's glow, the hammer's position, the still-hot bar). The prompts stated the next beat and let FLUX 3 handle the join.

Three things worth knowing about chains:

Latency compounds. Each clip in the chain takes a full FLUX 3 generation to render. A three-clip chain isn't three times faster than one 15-second call. It's three separate multi-minute renders. Reach for chaining when you need runtime beyond 20 seconds or narrative structure across a longer arc, not when you want the same duration cheaper.
Drift accumulates over long chains. Each continuation slightly reinterprets the state it inherits. Two chained continuations usually hold together cleanly. Three still work most of the time. Five in a row often start to drift on colour palette, ambient audio character, or subject appearance.
Recover drift by restarting the chain, not by patching mid-flight. When a chain gets muddy, don't try to correct the drift with prompt gymnastics on the next hop. FLUX 3 doesn't get more accurate as the chain gets longer. Instead, use the last clean clip in the chain (the one before drift set in) as a fresh source, prompt the next beat explicitly, and treat that as the start of a new short chain. If drift shows up right at the join, the source's final frame is usually the problem, not the prompt: regenerate the source with a cleaner ending state.

Landing an ending that didn't stick

Sometimes a first-pass generation doesn't finish where you wanted. A shot cuts to black mid-motion, the subject reaches a pose that isn't quite a punctuation mark, or the moment lands too quickly to breathe. Continuation lets you add the ending the clip needed without regenerating the whole shot.

Feed the incomplete clip as inputs.video, prompt the resolution you wanted, and the continuation adds it. Keep the assembled clip whole, or trim the source at the join and use only the continuation as your polished ending.

The example below is that pattern. The source is a 5-second runner mid-effort: a real beat, but ending on nothing in particular. The continuation adds the exhale: the runner comes to rest, hands to knees, a slow breath out. That closing beat is what turns the shot into a shot.

Source ending mid-stride, no landing beat

A 5-second locked-off side-tracking shot of a woman in her thirties in dark running gear finishing a hard sprint along a wide empty city sidewalk at dawn. She's still moving forward as the clip ends, arms pumping, breath visible in the cold air. Warm early morning light, empty shopfronts blurring past behind her. Audio: her heavy breathing, the rhythmic slap of running shoes on pavement, distant city ambience. No music, no on-screen text.

Continuation adds the closing beat

Continue the reference video from its final frames. The runner slows to a walk over the next two seconds, then stops and bends forward with her hands on her knees, chest heaving. She lifts her head, takes a slow deliberate exhale, and looks off down the empty street. The camera settles into a stationary hold on her as she catches her breath. Audio: her heavy breathing settling into deep controlled exhales, the last rhythmic footsteps fading, the same distant city ambience. No music, no on-screen text.

This pattern also handles the reverse problem: a shot that lands its beat but ends too fast to breathe. A 3-second continuation of "the subject holds the pose, the camera stays locked, the audio settles" gives the moment runtime to sit before the next cut.

Because you can trim either side of the join in the final assembly, continuation is effectively a surgical extension: you can add a few seconds of resolution, a few seconds of hold, or a whole new closing beat without touching what already worked.

Input constraints

The source clip passed as inputs.video is capped at 50 MB and 15 seconds. Larger or longer files are rejected with a validation error at request time.

If you don't have a source clip ready, generate one first with text-to-video (covered in the prompting guide) or image-driven video (covered in the keyframes guide) and use that output as the source for a follow-up video call.

Tips

Design source endings for the continuation you're planning. Motion resolved, camera at rest, audio landing on a clean beat, subject positioned where the next beat begins. Sources built this way continue invisibly. Sources that end mid-motion always leave a small stutter at the join.
Open continuation prompts with "continue the reference video from its final frames". The explicit framing tells the model to build forward rather than to interpret the source as a general reference.
Describe the join deliberately. Reference the source's last frame explicitly: "from the close-up of the teacup", "picking up from where the runner leaves the frame". The model uses that phrasing to align the opening of the continuation with the source's ending rather than starting somewhere adjacent.
Match the audio register at the join. If the source ends on a specific ambient layer (rain patter, room tone, a music bed), name the same layers at the start of the continuation. Silent joins between two audio-heavy clips read as a break. Naming the carry-through keeps the audio continuous.
Continuation is a surgical extension, not a full re-render. Reach for it when a clip almost works and needs a specific beat added (a closing exhale, a few seconds of hold, a proper resolution) rather than regenerating the whole shot from scratch.
Chain when you need runtime beyond 20 seconds. Chaining source → continuation → continuation extends the same arc across a longer piece. Two hops usually hold together. Three still work most of the time. Expect drift past that.
Recover from drift by restarting the chain from the last clean clip. Don't try to patch drift with a corrective prompt on the next hop. Use the last good clip as a fresh source and start a new short chain from there.
Keep source clips under 50 MB and 15 seconds. Both limits are hard rejects at the API. If your source is larger, trim or re-encode before sending.
Reach for t2v or i2v if you don't have a source clip. Generating a first clip with plain text-to-video and then continuing it with video is a normal FLUX 3 workflow, not a fallback pattern.
Trim at the join in post if the continuation lands better on its own. The continuation is a standalone mp4. When the source's ending doesn't add to the final piece, use only the continuation as your delivered clip.