FLUX 3 Max: The Fast AI Video Model (Text and Image to Video), Price per Second, API Code, Benchmarks and Which FLUX Model to Use

FLUX 3 Max is a text-to-video and image-to-video AI model released by fal on October 19, 2026, post-trained with Black Forest Labs on their FLUX 3 model. Its selling point is speed: a 10-second 720p clip in about 12 seconds, roughly 22 times faster than Seedance 2.5 and 10 times faster than base FLUX 3, while scoring 1,139 Elo on the Artificial Analysis image-to-video arena, tied with Seedance 2.5 and just behind MiniMax H3 (the confidence intervals overlap, so treat it as a tie for the top). Price: $0.17 per second of 720p video at list price, with a launch price of $0.0425 per second (75% off) until November 7, 2026, so a 10-second clip costs about $0.43 now and $1.70 later, with no subscription. You use it through fal's API (endpoint blackforestlabs/flux-3-max/text-to-video, plus an image-to-video endpoint) from Python or JavaScript; there are no downloadable weights, so it does not run locally. Below: what it does, pricing with worked costs, API code, how it compares with other video models, which FLUX model to use for what, and the open alternatives you can run on your own GPU.

The shop wanted short product videos for its listings: a jacket turning on a mannequin, a bag on a cafe table. Jake had a few hundred product photos and no video team. An image-to-video model that turns each photo into a 10-second clip in under a quarter of a minute, for less than fifty cents during launch, made the whole catalog feasible in an afternoon.

Interested in image and video AI? The cards below cover the FLUX 3 image model, an open video model, other fast models and local tools.

What is FLUX 3 Max?

FLUX 3 Max is a video generation model: you give it a text prompt, or a still image plus a prompt, and it returns a short video clip. Black Forest Labs, the team behind the FLUX image models, built FLUX 3 as a base for others to customize; fal's research team then post-trained it (extra training, reinforcement learning and inference optimization) for speed at high quality, and serves the result as FLUX 3 Max.

• Modes at launch: text-to-video and image-to-video, priced the same.
• Output: 720p video; clips of around 10 seconds are what the published speed and quality numbers use.
• Speed: about 12.45 seconds to render a 10-second 720p clip, against 277.80 seconds for Seedance 2.5 and 126.44 seconds for base FLUX 3.
• Where: fal's platform and API only; base FLUX 3's extra endpoints (keyframes, drafts, extending a clip) are not part of FLUX 3 Max.

How did it get ten times faster than the model it is built on? Video models are diffusion models: they start from noise and remove it over many steps, and each step runs the whole network over every frame. The main levers for speed are doing fewer steps without losing detail (distillation, where a fast model learns to match a slow one's results), training the model on what people actually prefer (the reinforcement learning fal mentions), and engineering the serving software to keep the GPUs busy. fal's research team applied all three to FLUX 3; the result keeps the base model's look while taking roughly a tenth of the time.

Image-to-video is the mode most businesses want: it keeps your product, logo and colors from the photo and adds the motion, instead of inventing a new product from a text description.

Jake: "So I give it the jacket photo and it makes the jacket turn?"

Ethan: "And it keeps the actual jacket. That's why image-to-video matters for a shop."

Who is Black Forest Labs?

Black Forest Labs is the German AI company behind the FLUX models, based in Freiburg im Breisgau at the edge of the Black Forest, which gave it its name. It was founded in 2024 by researchers from the team that developed latent diffusion, the technique underneath Stable Diffusion, and is led by CEO Robin Rombach. In other words, the people who made open image generation mainstream left to build the next generation, and FLUX quickly replaced Stable Diffusion as the default open image model for many creators.

The company raised a $31 million seed round led by Andreessen Horowitz in August 2024 and a $300 million Series B at a $3.25 billion valuation in December 2025, with Salesforce Ventures among the leads and Canva and Figma Ventures among the strategic investors. That list says something about where FLUX ends up: inside design tools you may already use, as well as in its own API.

How Black Forest Labs makes its models available, which matters when you pick one:

• Open weights for the smaller models (the Klein line), free under the FLUX Kommunity License for businesses below $5 million in yearly revenue.
• The BFL API for the larger models, paid per image or per second of video.
• The BFL Playground, a web interface for trying the hosted models without code.
• Partners such as fal and OpenRouter, which serve FLUX models through their own APIs, and in fal's case co-develop variants such as FLUX 3 Max.

The FLUX model family, from FLUX.1 to FLUX 3 Max

Two naming habits explain the list: dotted versions (FLUX.1, FLUX.2) for the image generations, and "FLUX 3" with a word after it for the newest products. "Klein" (German for small) always means the open model you can run yourself.

FLUX 3 Max pricing, with worked costs

Three things change your real cost. You pay per second of output, with no subscription or minimum. Every attempt is billed, including the ones you throw away, so budget for several tries per keeper shot. And the launch price ends on November 7, 2026, so a batch job is cheaper this fortnight than it will be next month.

Two more budgets people ask about. A social account posting three 10-second clips a day for a month uses 900 seconds of finished video; with two tries per keeper that is 1,800 billed seconds, about $77 at the launch price and about $306 at list price. A small agency making ten 30-second ads a month, each built from three shots with four tries per shot, bills 1,200 seconds: about $51 at launch and $204 at list. In both cases the tries, not the keepers, are most of the bill, which is why a tested prompt library pays for itself quickly.

Ways to keep the bill down without lowering quality:

• Test prompts at 5 seconds, then render 10-second versions only of prompts that already work.
• Use a cheap still first: get the starting frame right as an image (FLUX 3 Image Klein runs free locally), then pay for motion once.
• Reuse prompts by product type instead of writing a new one for every item.
• Batch before November 7 if you have a large back catalog, while the launch discount applies.

FLUX 3 Max vs FLUX 3 Video: which one to call

FLUX 3 Max is built on Black Forest Labs' FLUX 3 Video, and the two are easy to confuse. The practical differences:

Use FLUX 3 Max when you need many clips quickly and 720p is enough: product loops, social posts, drafts for a storyboard. Use FLUX 3 Video when you need 1080p, clips longer than ten seconds, or precise control over where a shot starts and ends, such as matching a cut between two scenes. A common workflow uses both: explore ideas with Max at launch prices, then render the chosen shots with FLUX 3 Video's keyframes and upscale the finals.

Jake: "So Max for the catalog, and the base model for the one hero video on the homepage?"

Ethan: "Exactly. Speed where you need volume, control where you need one perfect shot."

Is there a free FLUX video generator?

Searches for a "free FLUX video generator" usually end on sites that resell API calls with a few trial credits. The straight answer for October 2026:

• FLUX 3 Max has no free tier; every second of output is billed on fal, though at launch prices a 10-second test costs under fifty cents.
• FLUX 3 Video is also paid; its draft mode, at about $0.06 per second, is the cheapest way to test prompts.
• Black Forest Labs announced an open FLUX 3 Video model alongside the August launch; check the company's Hugging Face page for whether it has shipped before you plan around it.
• Free and local today: open video models such as LTX-2.5 run on your own GPU at no per-clip cost; our LTX-2.5 guide covers the hardware.
• Free stills: FLUX 3 Image Klein is free to run locally for most small businesses, and its images make good starting frames for paid image-to-video later.

Be wary of any site offering "unlimited free FLUX video": either the quality is a different model with FLUX in the name, or someone else is paying until they stop.

How to use FLUX 3 Max: Python and JavaScript

Create an account and an API key on fal, set it as FAL_KEY, and call the endpoint. In Python:

pip install fal-client

import fal_client   # reads FAL_KEY from the environment

result = fal_client.subscribe(
    "blackforestlabs/flux-3-max/text-to-video",
    arguments={"prompt": "A navy wool jacket turns slowly on a mannequin in a bright studio, soft shadows, slow push-in."},
)
print(result["video"]["url"])

In JavaScript:

import { fal } from "@fal-ai/client";

const result = await fal.subscribe("blackforestlabs/flux-3-max/text-to-video", {
  input: { prompt: "A leather bag on a cafe table, morning light, gentle handheld camera drift." },
  logs: true,
});
console.log(result.data.video.url);

For image-to-video, call the blackforestlabs/flux-3-max/image-to-video endpoint with your photo's URL and a prompt describing the motion; the endpoint's API page lists the exact input fields and options such as aspect ratio. A batch job for a catalog is then a loop over your product images:

1. Upload or host each product photo at a URL the API can read (fal's storage helper, or a presigned S3 URL).
2. Write one motion prompt per product type ("slow turn on a mannequin", "camera drifts across the table"), not per product.
3. Call the image-to-video endpoint for each photo; run a few in parallel.
4. Download each result from the returned URL and store it with the product ID.
5. Review before publishing: discard clips with warped logos or wrong colors, and re-run those with a simpler prompt.

For more than a handful of clips, use the queue instead of waiting on each call. fal_client.submit returns immediately with a request handle; you can collect results later, or pass a webhook_url so fal calls your server when each clip is ready. A compact batch script for a catalog:

import csv, urllib.request
from concurrent.futures import ThreadPoolExecutor
import fal_client

ENDPOINT = "blackforestlabs/flux-3-max/image-to-video"
PROMPTS = {"jacket": "The jacket turns slowly on a mannequin, static camera, soft studio light.",
           "bag": "Camera drifts slowly across the table toward the bag, morning light."}

def make_clip(row):
    for attempt in range(2):
        try:
            result = fal_client.subscribe(ENDPOINT, arguments={
                "image_url": row["image_url"], "prompt": PROMPTS[row["type"]]})
            urllib.request.urlretrieve(result["video"]["url"], f"clips/{row['sku']}.mp4")
            return row["sku"], "ok"
        except Exception as err:
            last = err
    return row["sku"], f"failed: {last}"

rows = list(csv.DictReader(open("products.csv")))      # sku,type,image_url
with ThreadPoolExecutor(max_workers=4) as pool:
    for sku, status in pool.map(make_clip, rows):
        print(sku, status)

Why the queue matters: subscribe keeps a connection open until the clip is done, which is fine for a script on your laptop but wasteful in a serverless function billed by the second. With submit, your code hands over the job and moves on; fal renders it and either holds the result for you to fetch with the request ID or calls your webhook. For a few hundred clips that is the difference between a function waiting for hours and a function that runs for seconds per product. Keep the concurrency modest (four to eight at a time) so a rate limit does not turn into a burst of failed jobs.

Check the endpoint's API page for the exact input field names before you run it on a full catalog, and start with five products. The image_url can be a presigned S3 link with a few hours' expiry, so your product photos stay private.

Jake: "Three hundred clips, and the slow part was me watching them."

Ethan: "Twelve seconds each to make, a minute each to check. That's the right way round."

FLUX 3 Max benchmarks and how it compares

Read it as: the top few models are statistically tied on quality, and FLUX 3 Max is by far the fastest of them. MiniMax's faster "H3 Max" variant renders even quicker in fal's comparison (about 7.5 seconds), so speed alone is not unique. The scores come from a preliminary leaderboard and the timing from fal's own tests at 16:9, 720p (768p for MiniMax), so judge with your own prompts, especially for faces, hands and text, which every video model still gets wrong sometimes.

Who makes the models in that table, and how you reach them, matters as much as the score:

• MiniMax H3 comes from MiniMax in China, through its own API and resellers; its H3 Max variant is even faster.
• Seedance 2.5 is ByteDance's model, strong on quality and slow to render.
• Gemini Omni Flash 1.1 is Google's, reachable through Google's AI services.
• Wan 3.0 comes from Alibaba's Wan line, whose earlier versions were released with open weights.
• FLUX 3 and FLUX 3 Max come from Black Forest Labs and fal, through their APIs and partners.

If you already pay one provider for other AI services, that can decide it; the quality differences at the top are small enough that billing, data terms and speed often matter more.

Text-to-video or image-to-video: which to use

Both modes cost the same with FLUX 3 Max, but they suit different jobs. Text-to-video invents everything from your description: good for mood shots, backgrounds, concepts and stock-style footage where no specific product must appear. Image-to-video starts from a picture you supply and adds motion: right whenever the exact product, person, place or brand must be recognizable, because the model keeps what it sees instead of imagining it.

A useful rule: if you would be unhappy to see a slightly different version of the thing in the clip, use image-to-video. That covers products, packaging, logos, your shop front and your staff (with their consent). Text-to-video is for everything around them: the cafe atmosphere, the city street, the abstract background behind a sale banner. Many good ads combine both, with text-to-video establishing shots and image-to-video product shots cut together.

Jake: "I tried text-to-video for the jacket and got a nicer jacket that we don't sell."

Ethan: "That's text-to-video doing its job. For products, always start from the photo."

Which FLUX model should you use?

"Which FLUX model to use" depends on whether you want stills or video, and whether it must run on your own machine:

• Video, fast, through an API: FLUX 3 Max (this page).
• Video with keyframes, drafts or clip extension: base FLUX 3 on fal, which has those extra endpoints.
• Still images on your own GPU: the FLUX 3 image models; our FLUX 3 Klein guide covers running the small one locally.
• Still images through an API: Black Forest Labs' hosted FLUX image models.
• Video on your own GPU: an open video model instead (see below).

Some typical cases. An online shop animating product photos: FLUX 3 Max image-to-video, because volume and speed matter more than 1080p. A brand film or homepage hero shot: FLUX 3 Video with start and end keyframes, then FLUX Video Upscale on the final cut. A designer making social graphics: FLUX 3 Image through the BFL API, or Klein on a local GPU for unlimited drafts. A developer prototyping an app feature: FLUX 3 Max on fal, since the launch price makes testing cheap and the API is simple. A business that cannot send images to an outside service: Klein locally for stills and an open video model for motion.

Prompt tips for image-to-video

Build each image-to-video prompt in this order:

1. The motion, not the product: the image already shows the jacket, so say "turns slowly", "steam rises", "the bag's strap sways".
2. One movement per clip: a turn, a pan or a zoom. Asking for three actions in 10 seconds produces warping.
3. The camera: "static camera", "slow dolly in" or "handheld drift" gives far more predictable results than leaving it out.
4. The light, matching the photo; "golden hour" on a white studio shot fights the image.
5. The mood words last, if any ("calm", "premium"); they matter less than the first four.

And choose source photos with large, sharp labels: logos and text smaller than a few percent of the frame are where every video model smears.

Text-to-video prompts need more than image-to-video ones, because nothing in the frame is decided yet. A structure that works, with an example for each part:

Put together: "Close-up of a ceramic coffee cup on a wooden counter in a small cafe; steam rises as milk is poured in; slow dolly in, shallow depth of field; warm morning window light, natural colors." Change one part at a time between tries, and write down what each change did; a small prompt library by product type is worth more than any single clever prompt.

Aspect ratios and formats for each platform

Generate in the shape you will publish, because cropping a 16:9 clip to vertical later throws away most of the frame and often cuts off the product:

• 9:16 vertical: Instagram Reels, TikTok and YouTube Shorts.
• 1:1 square: many marketplace listings and feed posts.
• 4:5 or 3:4: feed posts that take more screen height than square.
• 16:9: websites, YouTube and presentations.
• 21:9: cinematic website headers (FLUX 3 Video supports it).

For image-to-video, match the source photo to the target ratio before you upload; a square product photo asked to become a 9:16 clip makes the model invent the missing top and bottom. Short clips loop well on product pages, so a gentle movement that ends where it began (a full turn, a slow drift back) works better than one that ends mid-motion.

File size matters on product pages too. A 10-second 720p clip compressed with H.264 at a sensible quality setting is usually small enough to autoplay muted on mobile without slowing the page; re-encode with ffmpeg's -crf setting (as in the editing section below) if a clip is heavier than your other page assets.

Editing FLUX videos: trim, join, upscale and add sound

A generated clip is raw footage. A few free tools turn it into a finished piece. With ffmpeg, trim the first half second (where many models start a little unsteady) and join several shots into one ad:

ffmpeg -ss 0.5 -i shot1.mp4 -c:v libx264 -crf 18 -an shot1_trim.mp4
# list.txt contains lines like: file 'shot1_trim.mp4'
ffmpeg -f concat -safe 0 -i list.txt -c copy ad.mp4
ffmpeg -i ad.mp4 -i music.mp3 -c:v copy -c:a aac -shortest ad_with_music.mp4

• Upscaling: FLUX Video Upscale, launched in August 2026, lifts generated or existing clips to a higher resolution, priced per megapixel-second (about $0.075 to $0.105 depending on the mode). Upscale only the finals, not every draft.
• Sound: FLUX 3 Max clips are silent at launch; add licensed music, a voice-over or sound effects in your editor.
• Captions and text: add them in the editor rather than asking the model to draw them, since generated text in video still smears.
• Color matching: when you join clips made from different prompts, a quick color correction in a free editor such as DaVinci Resolve makes them look like one shoot.

Common video artifacts and how to fix them

• Morphing products (a bag changing shape mid-clip): too much motion or too many actions; ask for one slow movement and keep the product centered and large.
• Warped hands and faces: shorten the action, use a closer shot, or avoid hand close-ups for product videos.
• Flicker in lighting or texture: describe the light once and keep it constant; mixed light words ("sunset" and "studio") make it shift.
• Smeared logos and labels: use a sharper, larger source image and slower motion, and keep important text big in the frame.
• A different-looking product in image-to-video: the prompt describes the product differently from the photo; describe only the motion and let the image define the product.
• Unwanted camera shake: say "static camera" or "tripod shot" explicitly.

Jake: "The red bag kept turning orange halfway through."

Ethan: "Your prompt said 'golden hour'. The model changed the light, and the color went with it. Say 'neutral studio light'."

Can you run FLUX 3 Max locally?

No. FLUX 3 Max exists only as a hosted model on fal; no weights are available to download, so there is no ComfyUI, Ollama or LM Studio version. If you need video generation on your own hardware (for privacy, unlimited tries, or no per-second bills), use an open video model such as LTX-2.5; our LTX-2.5 guide covers the GPU you need. Expect slower generation and lower quality than the top hosted models, on a 24 GB or larger graphics card. For still images locally, the FLUX 3 image models and Qwen-Image 2.1 Turbo are good starting points.

What "local video" means in practice: a 24 GB card such as an RTX 4090 renders short, lower-resolution clips in minutes rather than seconds, and a 32 GB RTX 5090 or a 48 GB workstation card makes longer or sharper clips practical. Workflows run in ComfyUI, where open video models have ready-made templates. The upside is no per-second bill and full privacy, which matters for unreleased products; the downside is your time, your electricity and a quality gap to the best hosted models.

A hybrid that many small teams settle on: design the starting frame locally with FLUX 3 Image Klein (free, unlimited tries, private), then send only the approved frame to FLUX 3 Max for motion. You pay for seconds of video only once the look is decided. If Black Forest Labs ships the open FLUX 3 Video model it announced in August, a fully local FLUX pipeline becomes possible; until then, the hybrid is the practical route.

A complete product-video workflow for an online shop

Most of the quality of an image-to-video clip is decided before you call the API, by the photo you start from. A workflow that gives consistent results across a whole catalog:

1. Shoot or pick clean photos: the product large and centered, a plain or simple background, even light without harsh shadows, at least 1080 pixels on the short side.
2. Crop to the target shape (square for listings, vertical for social) before uploading, leaving a little space around the product for the motion.
3. Group products by type and write one tested motion prompt per group: clothing turns, bags get a camera drift, food gets steam or a pour, electronics get a slow push-in with a screen glow.
4. Run a five-product pilot, review it with whoever approves listings, and adjust prompts before the full batch.
5. Run the batch with the queue script above, saving clips under the product's SKU.
6. Review every clip against the photo: same color, same shape, no extra features, readable logo. Re-run failures once with a simpler prompt, then fall back to the still photo.
7. Publish with the listing, muted and looping, and track whether listings with video sell better before extending the work to the rest of the catalog.

Jake: "Some sellers on the marketplace get listings pulled for videos that don't match the product."

Ethan: "That's step six. If the clip changes the color or adds a pocket, it doesn't go up."

Do product videos sell more? Test it on your own store

Marketplaces and shop platforms often say listings with video perform better, but your products and customers decide whether that holds for you, and it is cheap to check. Pick two similar groups of products, add video to one group only, and compare click-through, add-to-cart and returns over a few weeks of normal traffic. Keep everything else the same: price, title, photos and promotions. If the video group wins clearly, extend video to the rest of the catalog at whichever price applies then; if it does not, you have spent a few dollars instead of a few hundred.

Watch returns as closely as sales. A clip that makes a product look better than it is can raise orders and returns together, which is a loss. That is one more reason to start from your real photos and reject any clip that changes the product. For services and food, where motion shows something a photo cannot (steam, texture, a pour), the gains tend to be easiest to see.

Running FLUX 3 Max jobs from AWS

FLUX 3 Max is not an AWS service, but it fits neatly into an AWS pipeline when your product photos already live in S3:

• Trigger: an S3 upload event, or a scheduled EventBridge rule for nightly batches, starts the job.
• Input: a Lambda function creates a presigned GET URL for each photo with a short expiry, so fal can read it without the bucket being public.
• Call: the function submits the request to fal's queue with a webhook pointing at an API Gateway endpoint, instead of waiting for the render inside Lambda.
• Result: the webhook handler downloads the finished clip from fal's URL and writes it to S3 next to the photo, tagged with the SKU.
• Secrets: the FAL_KEY lives in Secrets Manager, read once per container.
• Tracking: a DynamoDB table holds each job's status, so failures can be retried and costs counted per product.

Step Functions can orchestrate the same steps with built-in retries if you prefer a visual workflow. Either way, set a monthly budget alert on the fal side as well as in AWS, because the video bill arrives from fal, not from your AWS account.

Using the Black Forest Labs API and Playground

FLUX 3 Max lives on fal, but Black Forest Labs runs its own API and web Playground for the rest of the family, which is where most people meet FLUX first. The shape is the same as any image or video API: create an account, add credits, create an API key, and call a model endpoint with a prompt (and images for editing or image-to-video). The Playground runs the same hosted models in the browser, which is the quickest way to judge whether FLUX 3 Image or FLUX 3 Video suits your style before writing code.

Three tips when you move from the Playground to the API. Keep the exact prompt and settings that worked, since the API will not remember them for you. Store generated files yourself straight away, because result URLs from image and video APIs expire. And keep keys server-side: a key built into a web page or app can be copied and spent by anyone, the same risk our API key guide describes for language models.

Commercial use and rights

Videos you generate through the fal API can be used in commercial projects, under fal's terms of service, which you should read for the details that matter to your business (ownership, restrictions on likenesses and brands, content policies). Practical cautions for product videos: generate from your own photos, check that logos and labels are not distorted before publishing, and label videos made with AI where your marketplace or local advertising rules require it. Some marketplaces also ask that product videos show the real item accurately, so a clip that changes a color or adds a feature the product lacks can get a listing removed.

Platforms have their own rules on top. YouTube asks creators to disclose realistic altered or synthetic content, TikTok and Meta label content made with AI and ask you to mark it, and many marketplaces require that product media show the item as sold. A simple policy covers most cases: label clips as made with AI where the platform asks, never generate real people's likenesses without consent, and keep brand logos to your own products.

Jake: "Do we own these clips?"

Ethan: "We can use them commercially under fal's terms. Read the terms once, keep our own photos as the source, and we're fine."

Common problems and fixes

• 401 or authentication errors: FAL_KEY is missing or wrong in the environment where the code runs.
• The image cannot be read: the photo URL is private or expired; use a public URL, fal's upload helper or a fresh presigned URL.
• Warped products or logos: simplify the motion, use a larger and sharper source image, and keep the product centered.
• The bill is higher than expected: every attempt is charged per second; generate short drafts first and keep 10-second renders for prompts you have already validated.
• Prices changed: the 75% launch discount ends on November 7, 2026; the list price is $0.17 per second at 720p.

Frequently asked questions

The shop's 300 product clips were generated in one afternoon at launch pricing, for about the cost of a single studio hour. Jake kept the prompts in a small table by product type, so next season's catalog is one script run. Ethan set a calendar reminder for November 7, when the price goes up fourfold, to decide which product lines are worth video at list price.

Revision note. Written October 20, 2026, the day after launch, at launch-discount prices. We will update the prices when the discount ends on November 7.