Progressive training visualization: Base model only (left) → 6000 training steps (right)
***
## Part 3: Sampling Configuration
Sampling settings at inference matter just as much as training config — they need to match.
### Recommended Sampling Parameters
**Inference Steps: 8**
Significantly reduced from typical ranges (20 to 50 steps). Aligns with reduced training duration to preserve soft, painterly, impressionistic qualities.
***
## Output Examples
FLUX 3
Overview
One model trained across image, video, and audio. Video with synchronized
sound, live now.
## One model, multiple modalities
FLUX 3 generates **video with synchronized audio**:
from a text prompt, from pinned keyframes, or continuing an existing clip.
More modalities ship on the same request shape as they land.
* **Up to 20 seconds at FHD** (1920 × 1088 for 16:9), 24 fps, in a single request.
* **Multilingual speech with strong lipsync**, plus effects and ambience, generated with the frames.
* **Multiple scenes and camera angles in one generation.** Shots hold together across cuts.
* **Stylistic range beyond cinematic:** animation, motion design, stylized artistic looks.
* **Accurate text and typography** rendered inside the scene.
FLUX 3 is a **preview** model. **Video editing** and **Omni Reference with
images and videos** will be available soon.
## Modes
Every request names a mode. The mode is how you tell FLUX 3 what you're
starting from, and it decides what the model does with your media: start a
clip from words alone, build one around images you pin, or carry an existing
clip forward.
There are three:
* **Text to Video** (`t2v`) starts from nothing but your prompt.
* **Image to Video** (`i2v`) starts from your images. They become frames of the clip itself.
* **Video Continuation** (`v2v`) starts from a clip you already have and keeps it going.
All three run on the same [flux-3-video endpoint](/api-reference/utility/generate-a-video-with-flux-3), and
the rest of the request looks identical. To show how they connect, everything
below is **one scene passed through the whole API**: the first request
generates a clip, and every request after it runs on that clip's own frames.
Each tab shows the request we sent and the video that came back.
Describe the shot. `t2v` turns the prompt into a clip, sound included.
This is the request that started the scene:
```bash theme={null}
curl -X POST https://api.bfl.ai/v1/flux-3-video \
-H "x-key: $BFL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"mode": "t2v",
"prompt": "she takes his hand and pulls him laughing through the lantern-lit alley, the camera chasing them, paper lanterns swaying overhead, their footsteps and laughter echoing off the walls",
"duration": 8
}'
```
The clip this request returned. The next two tabs build on it.
There is no separate start-frame field: `keyframes` is how you hand `i2v`
images, and one image is the start frame. We extracted the **opening frame
of the clip in the first tab** and pinned it, with a new camera direction:
```bash theme={null}
curl -X POST https://api.bfl.ai/v1/flux-3-video \
-H "x-key: $BFL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"mode": "i2v",
"prompt": "from this frame the camera rises slowly above the alley as they rush away beneath the lanterns, their laughter fading into the night",
"keyframes": "data:image/png;base64,"
}'
```
Same first frame, different film: the pinned image opens the clip exactly, then the prompt takes over.
More images, more control: two pin the start and end frames, up to ten
storyboard the clip, and `[seconds, image]` pairs pin each one to an
exact moment. Here the hero clip's **first and last frames** are pinned at
`0` and `8` seconds and the model finds its own path between them:
```bash theme={null}
curl -X POST https://api.bfl.ai/v1/flux-3-video \
-H "x-key: $BFL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"mode": "i2v",
"prompt": "they sprint the length of the lantern-lit alley, lanterns blurring past, footsteps quick on the wet stones",
"keyframes": [[0, "data:image/png;base64,"], [8, "data:image/png;base64,"]],
"duration": 8
}'
```
Both pins hit exactly; the sprint in between is the model's.
`v2v` picks up where your clip ends. Momentum, framing, and scene logic
carry into the new footage. We sent the **first tab's clip** as
`start_video` and asked for the scene's next beat:
```bash theme={null}
curl -X POST https://api.bfl.ai/v1/flux-3-video \
-H "x-key: $BFL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"mode": "v2v",
"prompt": "they burst out of the alley into a crowded night market, drums and street chatter swelling, she pulls him into the lantern light",
"start_video": "data:video/mp4;base64,",
"duration": 8
}'
```
The same couple, out of the alley and into the market: continuation keeps the scene's logic and sound.
Everything else is optional. Set any field explicitly and it is used exactly;
leave it out and the default takes over:
* **`aspect_ratio`** and **`duration`** default to `auto` and fit themselves to the content.
* **`resolution`** defaults to `hd`; `fhd` finishes the result at a higher resolution via the video upsampler.
* **`generate_audio`** defaults to `true`.
The full field list, constraints, and dimensions live in the
[API reference](/api-reference/utility/generate-a-video-with-flux-3).
## Draft mode
Iterate in draft, commit once. Drafts generate faster and cost about a third
of a full render, so you can explore variants freely and only pay full price
for the shot you keep.
* **`draft: true`** returns a fast preview instead of a full render, plus a `draft_cache` bundle in the result.
* **`mode: "draft_enhance"`** renders the preview you picked at full quality: send its bundle as `draft_cache` and the original generation is reproduced. Same shot, same seed, nothing re-interpreted.
Here is the same prompt run through all three paths:
Each fresh submit is its own generation, so the direct full render can
interpret the shot differently from the draft you liked. Enhancing keeps it:
Enhanced: the draft's shot, full quality
Direct full render: its own take
```bash theme={null}
curl -X POST https://api.bfl.ai/v1/flux-3-video \
-H "x-key: $BFL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"mode": "t2v",
"prompt": "a fox running through dawn mist",
"draft": true
}'
```
Download the winning preview's `draft_cache` URL from its result, then send
the bundle back:
```bash theme={null}
curl -X POST https://api.bfl.ai/v1/flux-3-video \
-H "x-key: $BFL_API_KEY" \
-H "Content-Type: application/json" \
-d "{
\"mode\": \"draft_enhance\",
\"draft_cache\": \"$(base64 -i draft_cache.bin)\"
}"
```
Limits and constraints are in the [API reference](/api-reference/utility/generate-a-video-with-flux-3).
## Specifications
| Mode | You send | Length | Full render | Draft |
| ---------------------- | ---------------------- | ------ | ------------------------- | -------- |
| **Text to Video** | a prompt | 5–20 s | \$0.17/s hd, \$0.29/s fhd | \$0.06/s |
| **Image to Video** | a prompt + 1–10 images | 5–20 s | \$0.17/s hd, \$0.29/s fhd | \$0.06/s |
| **Video Continuation** | a prompt + your clip | 5–15 s | \$0.43/s hd, \$0.54/s fhd | \$0.12/s |
Every mode outputs 24 fps at `hd` or `fhd`, in aspect ratios 21:9, 2:1, 16:9,
4:3, 1:1, 3:4, and 9:16. Drafts render at `hd`.
## What it can do
## Start in ten seconds
FLUX 3 is asynchronous. You **submit** a request and get back an `id` and a
`polling_url`; then you **poll** that URL until the job turns `Ready` and returns
your result. Here is the full round trip, text to video with audio.
Result URLs are signed and expire about 2 hours after the job finishes.
Download the video promptly once the status is `Ready`.
## Getting started
Create an account, add credits, and make your first FLUX 3 call.
Test FLUX 3 in your browser. No setup required.
Generate from text, animate stills, pin keyframes, continue clips, all with audio.
The full flux-3-video request contract: modes, fields, constraints.
# Video
Source: https://docs.bfl.ml/flux_3/flux3_video
Generate, animate, and continue video with FLUX 3. Up to full-HD and 20 seconds, with synchronized audio.
FLUX 3
Video
Generate, animate, and continue video with FLUX 3, with
synchronized audio in the same call.
## Quickstart
FLUX 3 video is asynchronous: you **submit** a request, get back a `polling_url`,
and **poll** it until the clip is `Ready`. For the full field list and response
schema, see the [API reference](/api-reference/utility/generate-a-video-with-flux-3).
```python Python theme={null}
import os, time, requests
BFL_API_KEY = os.environ["BFL_API_KEY"]
# 1. Submit — returns an id and a polling_url
submit = requests.post(
"https://api.bfl.ai/v1/flux-3-video",
headers={"x-key": BFL_API_KEY, "Content-Type": "application/json"},
json={
"mode": "t2v",
"prompt": "a fox running through dawn mist",
"generate_audio": True,
},
).json()
# 2. Poll the returned URL until the job is Ready
while True:
time.sleep(2)
result = requests.get(submit["polling_url"], headers={"x-key": BFL_API_KEY}).json()
if result["status"] == "Ready":
print(result["result"]["sample"]) # signed .mp4 URL
break
if result["status"] in ("Error", "Request Moderated", "Content Moderated"):
raise RuntimeError(result["status"])
```
```bash cURL theme={null}
# 1. Submit — returns an id and a polling_url
curl -s -X POST https://api.bfl.ai/v1/flux-3-video \
-H "x-key: $BFL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"mode": "t2v",
"prompt": "a fox running through dawn mist",
"generate_audio": true
}'
# 2. Poll the polling_url from the response until "status": "Ready"
curl -s "$POLLING_URL" -H "x-key: $BFL_API_KEY"
```
## Modes
One `mode` per request; the rest of the request stays the same.
* **Text-to-Video** (`t2v`) — prompt only.
* **Image-to-Video** (`i2v`) — add `keyframes`: one image is the opening frame, `[a, b]` pins start and end, and up to ten frames pinned to timestamps become a storyboard.
* **Video Continuation** (`v2v`) — add `start_video`; the clip continues from its final frames.
t2v · Generate a video with audio
i2v · Animate an image and use multiple keyframes
## Parameters
Full schema and per-field constraints live in the [API reference](/api-reference/utility/generate-a-video-with-flux-3).
| Field | Required | |
| ------------------ | ------------------- | ---------------------------------------------------------------------------------------------------------- |
| `mode` | always | `t2v`, `i2v`, `v2v`, or `draft_enhance`. |
| `prompt` | always | What to generate. |
| `keyframes` | for `i2v` | One image starts the clip, two pin start and end, `[seconds, image]` pairs pin exact times. URL or base64. |
| `start_video` | for `v2v` | The clip to continue from, mp4 as URL or base64. |
| `draft_cache` | for `draft_enhance` | The bundle from a prior draft; reproduces that generation at full quality. |
| `resolution` | | `hd` (default) or `fhd`. |
| `duration` | | Whole seconds, 5 to 20, or `auto` (default). |
| `aspect_ratio` | | `auto` (default), `21:9`, `2:1`, `16:9`, `4:3`, `1:1`, `3:4`, or `9:16`. |
| `generate_audio` | | On by default. Set `false` for a silent clip. |
| `safety_tolerance` | | 0 (strictest) to 4, default 2. |
| `draft` | | Set `true` for a fast hd preview; the result includes a `draft_cache` bundle. |
| `version` | | `latest` (default) — always tracks the current release. |
## Use cases
Deeply customizable, and built for use cases, visual styles, and aspect ratios
far beyond conventional cinematic output.
### Text to video
Generate a clip from words alone — FLUX 3 handles everything from a single line to a densely directed brief, filling in framing, motion, and mood wherever you leave them open.
```bash cURL theme={null}
curl -s -X POST https://api.bfl.ai/v1/flux-3-video \
-H "x-key: $BFL_API_KEY" -H "Content-Type: application/json" \
-d '{
"mode": "t2v",
"prompt": "a fox running through dawn mist",
"generate_audio": true
}'
```
### Image to video
Animate from images you pin. A single still becomes the exact opening frame, a start-and-end pair interpolates the motion between them, and several frames spread across the clip.
```bash cURL theme={null}
curl -s -X POST https://api.bfl.ai/v1/flux-3-video \
-H "x-key: $BFL_API_KEY" -H "Content-Type: application/json" \
-d '{
"mode": "i2v",
"prompt": "push forward through the trees",
"keyframes": "https://example.com/still.jpg"
}'
```
### Multiple scenes
Block several shots and camera angles in one generation. Character, look, and continuity hold across hard cuts, with a single audio bed carrying through.
```bash cURL theme={null}
curl -s -X POST https://api.bfl.ai/v1/flux-3-video \
-H "x-key: $BFL_API_KEY" -H "Content-Type: application/json" \
-d '{
"mode": "t2v",
"prompt": "SHOT ONE: wide aerial of a desert highway at dawn. HARD CUT. SHOT TWO: interior close-up of the driver. HARD CUT. SHOT THREE: the car shrinks into the heat haze. One music bed across all shots.",
"duration": 10
}'
```
### Multilingual dialogue
On-camera speech in many languages, with accurate accents and tight lipsync. Quote the line in your prompt and the character says it.
```bash cURL theme={null}
curl -s -X POST https://api.bfl.ai/v1/flux-3-video \
-H "x-key: $BFL_API_KEY" -H "Content-Type: application/json" \
-d '{
"mode": "t2v",
"prompt": "A presenter speaks to the lens: \"Storm season is here.\" Clean studio lighting.",
"generate_audio": true
}'
```
### Broad range of styles
Photoreal cinematography, animation, motion design, and stylized looks — the same model spans styles far beyond conventional footage.
```bash cURL theme={null}
curl -s -X POST https://api.bfl.ai/v1/flux-3-video \
-H "x-key: $BFL_API_KEY" -H "Content-Type: application/json" \
-d '{
"mode": "t2v",
"prompt": "2D hand-drawn animation of a fox leaping through a paper-cut forest, bold flat colors",
"aspect_ratio": "16:9"
}'
```
### Text and typography
Legible, well-placed text rendered as part of the scene — titles, signage, and lower-thirds that stay stable through motion.
```bash cURL theme={null}
curl -s -X POST https://api.bfl.ai/v1/flux-3-video \
-H "x-key: $BFL_API_KEY" -H "Content-Type: application/json" \
-d '{
"mode": "t2v",
"prompt": "Bold kinetic title card, the word \"FLUX\" assembling from light streaks on a dark stage",
"aspect_ratio": "16:9"
}'
```
### Keyframes
Pin ordered keyframes and FLUX 3 interpolates one continuous shot through each — hit this pose, then this composition, then this — while the model handles the motion between them.
![Keyframe — Start · 0:00]()
Start · 0:00
![Keyframe — Key 2 · 0:03]()
Key 2 · 0:03
![Keyframe — Key 3 · 0:07]()
Key 3 · 0:07
![Keyframe — End · 0:10]()
End · 0:10
![Keyframe — Start]()
Start
![Keyframe — Key 2]()
Key 2
![Keyframe — Key 3]()
Key 3
![Keyframe — End]()
End
![Keyframe — Start · 0:00]()
Start · 0:00
![Keyframe — Key 2 · 0:03]()
Key 2 · 0:03
![Keyframe — Key 3 · 0:07]()
Key 3 · 0:07
![Keyframe — End · 0:10]()
End · 0:10
![Keyframe — Start · 0:00]()
Start · 0:00
![Keyframe — Key 2 · 0:03]()
Key 2 · 0:03
![Keyframe — Key 3 · 0:07]()
Key 3 · 0:07
![Keyframe — End · 0:10]()
End · 0:10
```bash cURL theme={null}
curl -s -X POST https://api.bfl.ai/v1/flux-3-video \
-H "x-key: $BFL_API_KEY" -H "Content-Type: application/json" \
-d '{
"mode": "i2v",
"prompt": "a seed grows into a tree through the seasons",
"duration": 10,
"keyframes": [[0, "https://example.com/seed.png"], [4.5, "https://example.com/sapling.png"], [10, "https://example.com/tree.png"]]
}'
```
### Video continuation
Feed an existing clip and FLUX 3 picks up from its final frames, carrying momentum, framing, and scene logic forward without a cut.
```bash cURL theme={null}
curl -s -X POST https://api.bfl.ai/v1/flux-3-video \
-H "x-key: $BFL_API_KEY" -H "Content-Type: application/json" \
-d '{
"mode": "v2v",
"prompt": "she takes his hand and pulls him laughing through the lantern-lit alley, the camera chasing them",
"start_video": "https://example.com/clip.mp4",
"duration": 10
}'
```
## Keep exploring
Prompt formats, the schema, camera language, and audio.
The full flux-3-video request contract: modes, fields, and constraints.
Try FLUX 3 in your browser — no setup required.
One request shape across image, video, and synchronized audio.
# FLUX1.1 [pro] Image Generation
Source: https://docs.bfl.ml/flux_models/flux_1_1_pro
Generate images with FLUX1.1 [pro], a fast and reliable text-to-image model with strong prompt adherence and competitive pricing.
**FLUX1.1 \[pro]** is the standard for text-to-image generation with fast, reliable and consistently stunning results.
To generate an image from text, you’ll make a request to the `/flux-pro-1.1` endpoint.
## Key Features