FLUX 3: Klein Models, Access and API Code (2026)

FLUX 3 is the 2026 model family from Black Forest Labs, the German lab behind the original Flux image models, and it is broader than a single image generator. The name covers a multimodal foundation model that works across images, video and audio, a layout-focused image model, an open-weight image model called Klein, and even a model for robot control. If you searched for it because you want to generate or edit images, the part you can use right now with an API key is FLUX 3 Image Klein, and this guide shows exactly how, what it costs and where it fits.

A quick note on the name: “flux 3” also turns up in searches for the third season of Æon Flux, the third flux construct boss in Tears of the Kingdom, and various hardware parts. This article is only about the Black Forest Labs AI models.

What is FLUX 3?

FLUX 3 is a family of generative models built around one idea: a single foundation model that learns jointly from images, video and audio inside one unified architecture, rather than separate models stitched together. A foundation model is a large model trained on broad data that other, more specialised models are built on or distilled from. Here is what each member of the family does.

The multimodal FLUX 3 model

The flagship is described as one multimodal model for image, video, audio and action prediction. Because it learns from video and audio alongside still images, the goal is output that is truer to life across styles: motion, lighting and physical behaviour learned from video can inform how still images look. This is the model the announcement focused on, and it is the most capable but also the least openly available part of the family.

FLUX 3 Image

FLUX 3 Image is the image-focused product, and its headline feature is layout control. You give it references, and it decides where each one sits in the frame and how large it is, then renders the whole image around that layout. Every placed element stays editable, so you can move or resize a box and regenerate rather than rewriting the prompt and hoping. For design work where composition matters (ads, product grids, posters) that is a meaningful change from prompt-only generation.

FLUX 3 Image Klein

Klein (German for “small”) is the compact, open-weight image model: 5.6 billion parameters, handling text-to-image generation, image editing and multi-reference generation, meaning several input images can guide one output. Open weights means the trained model files are published, so you can download and run the model yourself instead of only calling someone else’s server. If you used the previous generation, our write-up on Flux 2 Klein covers its 4B and 9B variants for context.

FLUX 3 Action

FLUX 3 Action is a 7B open-weight “world action model” trained on video, image and audio data. It jointly predicts future video frames and the actions a robot should take. It is aimed at robotics researchers, not people making pictures, but it shows how far the shared FLUX 3 foundation is meant to stretch.

Is FLUX 3 released, and is it open source?

The short answer: the family is announced and partly released, and two members ship with open weights. The rollout happened in stages through 2026:

• July 2026: Black Forest Labs announced the multimodal FLUX 3 foundation model.
• September 2026: FLUX 3 Action, the 7B robot-control model, was published with open weights.
• October 2026: FLUX 3 Image Klein, the 5.6B image model, was released with open weights.
• 20 October 2026: Klein text-to-image and Klein editing went live on Unicorn API.

“Open source” gets used loosely for AI models, so be precise. Klein and Action are open weight: the files are downloadable. That is not the same as permissive licensing. The licence attached to the weights decides whether you can use outputs commercially, fine-tune and redistribute, or only experiment. Read it before you put a self-hosted model into a paid product. The flagship multimodal FLUX 3 model has not been described as open weight, so expect to reach it through hosted services rather than downloading it.

Where can you access FLUX 3?

There are four realistic routes, and which one is right depends on whether you want control, convenience or a single bill across many models.

1. Black Forest Labs directly

The lab offers its own access to the FLUX 3 models. This is the natural place to get the flagship multimodal model and the layout features of FLUX 3 Image as they roll out.

2. Run the open Klein weights yourself

Because Klein is open weight, you can download it from public model hubs and run it on your own GPU, including in node-based tools such as ComfyUI once support is in place. NVIDIA also hosts Klein on its developer platform. Self-hosting gives you full control and no per-image fee, but you pay in hardware, setup time and maintenance, and you are responsible for licence compliance.

3. Creative apps

Several image apps announced plans to add FLUX 3. These are fine for one-off creative work but are usually priced by subscription and are not built for programmatic use.

4. A hosted API with one key

If you are building an app, a hosted API is the shortest path: no GPUs, no model files, pay per image. On Unicorn API, Klein is available as two models:

• Flux 3 Klein Text to Image (flux-3-klein-text-to-image): generate from a prompt.
• Flux 3 Klein Edit Image (flux-3-klein-edit-image): edit or combine one or more input images under a prompt.

Both use the same jobs endpoint as every other image, video and audio model in the model catalog, so switching from FLUX 3 Klein to another model is a one-line change. If you want to see results before writing code, try both in the browser playground.

How to call FLUX 3 Klein through the API

Media models on Unicorn API are asynchronous. You create a job with POST /v1/jobs, get back a job id, then poll GET /v1/jobs/{id} until the status is "succeeded" and read the image URL from outputs[0].url. First, create a key on the API keys page and export it:

export UNICORN_API_KEY="your-key-here"

Text to image with curl

curl -X POST https://api.unicornapi.net/v1/jobs \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "flux-3-klein-text-to-image",
    "input": {
      "prompt": "A red fox resting in a snowy forest at dawn, soft light, highly detailed",
      "resolution": "2K",
      "seed": 42
    }
  }'

# Then poll with the id from the response:
curl https://api.unicornapi.net/v1/jobs/JOB_ID \
  -H "Authorization: Bearer $UNICORN_API_KEY"

A reusable Python helper

This script wraps the create-and-poll loop so you can call FLUX 3 Klein (or any media model) with one function. It covers both generation and editing.

import os
import time
import requests

API = "https://api.unicornapi.net"
HEADERS = {"Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}"}


def run_job(model, inputs, poll_seconds=2, timeout_seconds=300):
    """Create a job, wait for it to finish, return the output URLs."""
    resp = requests.post(
        f"{API}/v1/jobs",
        headers=HEADERS,
        json={"model": model, "input": inputs},
        timeout=30,
    )
    resp.raise_for_status()
    job_id = resp.json()["id"]

    deadline = time.time() + timeout_seconds
    while time.time() < deadline:
        job = requests.get(f"{API}/v1/jobs/{job_id}", headers=HEADERS, timeout=30)
        job.raise_for_status()
        job = job.json()
        if job["status"] == "succeeded":
            return [output["url"] for output in job["outputs"]]
        if job["status"] == "failed":
            raise RuntimeError(f"Job {job_id} failed: {job}")
        time.sleep(poll_seconds)
    raise TimeoutError(f"Job {job_id} did not finish in {timeout_seconds}s")


# 1. Generate a base image with FLUX 3 Klein text-to-image
base = run_job("flux-3-klein-text-to-image", {
    "prompt": "Matte black ceramic coffee mug on a light oak table, "
              "soft window light from the left, clean studio product photo",
    "resolution": "1K",
    "num_images": 2,
    "seed": 7,
})
print("Generated:", base)

# 2. Edit the first result with FLUX 3 Klein edit
edited = run_job("flux-3-klein-edit-image", {
    "prompt": "Same mug and table, but add steam rising from the mug "
              "and a small sprig of rosemary beside it",
    "image_urls": [base[0]],
    "resolution": "2K",
})
print("Edited:", edited[0])

The input fields worth knowing

• prompt: the description or edit instruction. Required.
• image_urls (edit model only): a list of publicly reachable image URLs. Pass more than one for multi-reference edits.
• resolution: "1K", "2K" or "4K". This is the main cost lever.
• aspect_ratio, or width and height: the output shape.
• num_images: how many outputs per job. Each one is billed.
• seed: fix it to reproduce a result, change it to get variations.
• enhance_prompt: lets the service expand a short prompt before generation.
• output_format and nsfw_checker: file format and safety filtering.

The API documentation lists accepted values for each field. If you work inside Cursor or Claude Code, the MCP setup lets your coding agent call the same models directly.

FLUX 3 Klein pricing per image

Both FLUX 3 Klein models share one price list, charged per output image and multiplied by num_images, with the total rounded up to whole credits:

Resolution	Listed rate	Billed for 1 image	Billed for 4 images
1K	1.6 credits	2 credits	7 credits (6.4 rounded up)
2K	2.5 credits	3 credits	10 credits
4K	6.5 credits	7 credits	26 credits

The rounding is why batching helps at 1K: four images in one job cost 7 credits, while four separate single-image jobs cost 8. On a monthly plan (Starter $25, Creator $50, Studio $100 or Pro $200) credits cost $0.01 each, so a single 1K FLUX 3 Klein image is about two cents. Top-up credits cost $0.015 each and never expire. You never have to guess: POST /v1/models/price returns the exact price of any request before you run it. Full plan details are on the pricing page.

How Klein compares with other image models

Price is only one axis, but it is the one that compounds when you generate thousands of images. Here are the listed per-image rates for other image models on the same key:

Model	Listed rate per image	Best for
Flux 3 Klein (text or edit)	1.6 / 2.5 / 6.5 credits at 1K / 2K / 4K	Cheap high-volume generation and editing, up to 4K
Seedream 5.0 Flash Image to Image	3.24 credits at any size up to 2K	Fast image-to-image transforms
GPT Image 1.5	3 / 4 / 22 credits at low / medium / high quality	Legible text, transparent backgrounds
Nano Banana 2 Lite	4 credits	Fast 1K edits with up to 10 reference images
Nano Banana 2.1	4 / 6 / 9 credits at 1K / 2K / 4K	Google’s newer image model at higher resolutions

Klein is the cheapest option in this list at every resolution it shares with the others. Where another model wins is on a specific feature: GPT Image 1.5 if you need a transparent background or reliable typography, Nano Banana 2 Lite if you want to feed up to ten references in one call. A sensible pattern is to draft with FLUX 3 Klein at 1K and only switch models when a job needs something Klein does not do well.

Worked example: a product-shot pipeline with FLUX 3 Klein

Suppose you run a small shop with 50 products and want three lifestyle shots of each, ready for a 2K product page. Here is a pipeline that keeps costs predictable.

1. Draft at 1K in batches. For each product, call the edit model with the plain product photo in image_urls, a scene prompt, resolution: "1K" and num_images: 4. That is 7 credits per product, 350 credits for all 50.
2. Pick winners. Review the 200 drafts and choose three per product. Note the seed of each keeper if you set seeds explicitly, so you can reproduce composition.
3. Final render at 2K. Re-run each chosen prompt with resolution: "2K" and one image per job. That is 150 jobs at 3 credits, 450 credits.
4. Total. About 800 credits, or roughly $8 of plan credits, for 150 finished 2K images plus 200 drafts. A Starter plan covers it with room to spare.

Two details make this work. First, drafting at 1K is cheap enough that you can afford to throw most images away, which is where good results come from. Second, rendering finals one per job means you are not paying 2K rates for images you will discard. Before running the full batch, send one representative request to the price endpoint to confirm the numbers for your exact inputs.

Common mistakes with FLUX 3

Most problems people hit with FLUX 3 Klein come from a handful of predictable errors.

• Confusing the family members. Klein is not the flagship multimodal FLUX 3 model. It generates and edits still images; it does not produce video or audio. If a tutorial shows layout boxes or video, it is describing a different member of the family.
• Defaulting to 4K. A 4K image costs about four times a 1K image. Use 4K for print or hero banners, not for thumbnails or drafts.
• Paying for unwanted variations. num_images multiplies the cost. Set it deliberately rather than leaving a high number in a config file.
• Private image URLs in edits. The edit model has to fetch everything in image_urls. Links behind a login, expiring signed URLs with short lifetimes, or localhost paths will fail.
• Polling too aggressively. A poll every second or two is plenty. Tight loops waste requests and gain nothing.
• Assuming open weights means free for anything. If you self-host Klein, the licence governs commercial use. Hosted API use avoids the GPU work, but read the terms for whichever route you choose.
• Writing paragraph-long prompts. Klein follows clear, concrete prompts well: subject, setting, lighting, camera framing. Stacking many competing style words usually muddies the result. Try enhance_prompt if your prompts are very short instead.

Should you use FLUX 3 Klein or wait for the full model?

If you need images today, use Klein. It is released, it is cheap per image, it handles both generation and editing, and you can move to the flagship FLUX 3 model later without rewriting your integration, because on Unicorn API every model is called the same way. Your run_job helper does not change; only the model id does.

Wait for the larger model only if your work specifically depends on what Klein does not offer: video and audio from one model, or the box-by-box layout editing of FLUX 3 Image. Even then, drafting with Klein now gives you a working pipeline, real cost data and a prompt library to carry forward.

To get started, create a key on the keys page, try a few prompts in the image playground, and paste the Python helper above into your project. One key and one bill cover FLUX 3 Klein and every other model in the catalog.