Flux 2 Klein: 4B vs 9B, Editing and API Code (2026)

Flux 2 Klein is the smallest and fastest branch of Black Forest Labs’ FLUX.2 image models, built for generating and editing images with very little wait, on modest hardware. If you searched for it, you probably want to know what it actually does, whether to pick the 4B or 9B version, what the licenses allow, and how to use it in a real project. This post covers all of that, plus working API code and the cost per image when you would rather not host a model yourself.

What is Flux 2 Klein?

FLUX.2 [klein], to use the official styling, is a pair of compact image models released by Black Forest Labs in January 2026. “Klein” is German for “small”, and that is the whole point: where the bigger FLUX.2 tiers aim for maximum quality, Klein aims for speed and lower compute requirements while keeping the core FLUX.2 abilities.

Those abilities come in one model rather than two separate tools:

• Text-to-image: you write a natural-language prompt and get an image back.
• Image editing: you give it an existing image plus an instruction (“make the sky stormy”, “swap the jacket to red leather”) and it changes the image while keeping the rest.
• Reference-guided generation: you supply images that steer style or content.

Like the rest of the FLUX family, Klein is a diffusion model: it starts from random noise and removes it step by step until an image matches the prompt. It works in a compressed “latent” space instead of raw pixels, which is a large part of why it can be fast. A latent is a smaller numeric representation of the image that the model edits before it is decoded back into pixels.

What makes Flux 2 Klein interesting in practice is the interaction speed. When a model answers fast enough, you stop treating image generation as “submit and wait” and start treating it like a slider: tweak, regenerate, tweak again. That is the workflow most of the top tutorials build around, and it is the one this article ends on.

Who makes it?

Black Forest Labs is a German AI lab founded by researchers who previously worked on latent diffusion and Stable Diffusion. It publishes both hosted models (Pro, Flex) and open-weight models (Dev, Klein). Klein is the most permissive and lightweight member of that line-up.

Flux 2 Klein 4B vs 9B: which one fits?

Flux 2 Klein ships in two sizes, named after their parameter counts: about 4 billion and about 9 billion. A parameter is one learned weight in the network; more parameters usually means more capacity for detail and prompt understanding, at the cost of memory and speed.

	Klein 4B	Klein 9B
License	Apache 2.0 (open, commercial use allowed)	Non-commercial
Tasks	Text-to-image and editing	Text-to-image and editing
Hardware	Lighter; aimed at consumer GPUs	Heavier; needs more GPU memory
Strength	Speed, easy fine-tuning, shipping in products	More capacity for detail and harder edits
Best for	Apps, LoRA training, real-time tools	Research, personal projects, quality tests

The license is the decision most people underestimate. Apache 2.0 lets you use, modify and redistribute the 4B weights in a commercial product, as long as you keep the license notice. The 9B weights carry a non-commercial license, so a paid app built on them needs a separate agreement. If you are building something you plan to sell, start with the 4B and only move to the 9B once you have checked the terms.

On quality, community testing generally finds the 9B handles editing tasks such as face changes, colourising old photos and complex object swaps a little more reliably. The 4B is the one people run on everyday machines and fine-tune most often.

Where Klein sits in the FLUX.2 family

FLUX.2 is a model series, not a single model. Knowing the tiers helps you decide whether Klein is the right tool or just the most talked-about one.

• FLUX.2 Pro: hosted, high-quality model focused on photoreal detail and prompt following.
• FLUX.2 Flex: hosted model with separate text-to-image and image-to-image versions, priced higher than Pro on most platforms because it is tuned for control.
• FLUX.2 Dev: open-weight model for developers and researchers, larger than Klein.
• FLUX.2 [max]: the top hosted tier for maximum quality.
• FLUX.2 Klein: the small, fast 4B and 9B models.

Black Forest Labs has since followed up with a newer Klein generation. Flux 3 Klein arrived on 20 October 2026 with separate text-to-image and edit endpoints, and that is the Klein model hosted on Unicorn API today. Here is how the hosted FLUX options compare on price per output image:

Model on Unicorn API	Task	1K	2K	4K
Flux 3 Klein Text to Image	Text-to-image	1.6 credits	2.5 credits	6.5 credits
Flux 3 Klein Edit Image	Editing	1.6 credits	2.5 credits	6.5 credits
Flux 2 Pro	Text-to-image, up to 8 reference images	5 credits	7 credits	n/a
Flux 2 Flex Text To Image	Text-to-image	14 credits	24 credits	n/a
Flux 2 Flex Image To Image	Image-to-image	14 credits	24 credits	n/a

Each request is rounded up to whole credits, so a single 1K Klein image costs 2 credits, which is $0.02 on a monthly plan. A single 2K image rounds to 3 credits. The rounding applies to the whole request, so four 1K images in one call cost 7 credits (6.4 rounded up), not 8. Full plan details are on the pricing page.

Running Flux 2 Klein locally

Because the weights are open, many people come to Flux 2 Klein wanting to run it on their own machine. The usual path looks like this:

1. Download the weights from Black Forest Labs’ official model release. Pick the 4B unless you have a reason and the GPU memory for the 9B.
2. Choose a runtime. Node-based tools such as ComfyUI are popular for visual workflows; Python libraries such as Hugging Face Diffusers suit scripts and services.
3. Load a workflow with a text-to-image path and an edit path (an input image node plus your instruction).
4. Tune settings such as resolution, seed and steps. A seed is the number that fixes the starting noise; reuse it to make results repeatable.

LoRAs and fine-tuning

A LoRA (low-rank adaptation) is a small add-on file that teaches a model a new style, character or product without retraining the whole thing. The Flux 2 Klein 4B is a natural target for LoRAs: it is small enough to train on a single decent GPU, and its Apache 2.0 license means you can ship the result. If you need a consistent brand look or recurring character, a Klein LoRA is often cheaper than prompting a larger model into consistency every time.

When local stops being worth it

Local hosting is great for experimentation and privacy. It gets harder when you need the model available to other people: you take on GPU costs while idle, queueing under load, driver and library updates, and monitoring. A related search people make is whether Klein runs in Ollama; check the current runtime support before planning around it, because image-model support in LLM-focused tools changes often. For production apps, a hosted endpoint that you pay per image is usually the simpler trade.

How to use Flux 2 Klein-style generation through an API

Unicorn API hosts the current Klein generation, Flux 3 Klein, alongside Flux 2 Pro and Flex, all behind one API key and one bill. If you came for Flux 2 Klein because you want small, fast, cheap images and edits, these endpoints give you that workflow without managing weights. Get a key from the keys page and export it as UNICORN_API_KEY.

Media models run as jobs: you POST a job, then poll it until its status is succeeded and read the image URL from outputs[0].url.

Generate an 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 ceramic coffee mug on a walnut desk, morning window light, product photo",
      "resolution": "1K",
      "aspect_ratio": "1:1",
      "seed": 42
    }
  }'

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

The text-to-image endpoint accepts prompt, resolution (1K, 2K or 4K), aspect_ratio, width and height, seed, num_images, output_format, enhance_prompt and nsfw_checker. The edit endpoint takes the same fields plus image_urls, the image or images you want changed.

If you want to check the cost before you run anything, the POST /v1/models/price endpoint returns the exact price of a request; the API docs show its usage. You can also try prompts in the browser playground first.

Worked example: a generate-and-edit loop in Python

The workflow Flux 2 Klein made popular is generate once, then refine with quick edits. Here is a complete Python script that does exactly that: it generates a product photo, then runs two edits on the result, each edit feeding on the previous output URL.

import os
import time
import requests

BASE = "https://api.unicornapi.net"
HEADERS = {
    "Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}",
    "Content-Type": "application/json",
}

def run_job(model, inputs, timeout=300):
    """Create a job, poll until it succeeds, return the first output URL."""
    r = requests.post(f"{BASE}/v1/jobs", headers=HEADERS,
                      json={"model": model, "input": inputs})
    r.raise_for_status()
    job_id = r.json()["id"]

    deadline = time.time() + timeout
    while time.time() < deadline:
        job = requests.get(f"{BASE}/v1/jobs/{job_id}", headers=HEADERS).json()
        status = job["status"]
        if status == "succeeded":
            return job["outputs"][0]["url"]
        if status in ("failed", "canceled", "cancelled", "error"):
            raise RuntimeError(f"Job {job_id} ended with status {status}: {job}")
        time.sleep(1.5)
    raise TimeoutError(f"Job {job_id} did not finish in {timeout}s")

# 1. Generate the base image
base_url = run_job("flux-3-klein-text-to-image", {
    "prompt": "A ceramic coffee mug on a walnut desk, morning window light, "
              "shallow depth of field, clean product photo",
    "resolution": "1K",
    "aspect_ratio": "1:1",
    "seed": 42,
})
print("Base:", base_url)

# 2. Edit: change the mug colour
edit1_url = run_job("flux-3-klein-edit-image", {
    "prompt": "Make the mug matte sage green, keep everything else unchanged",
    "image_urls": [base_url],
    "resolution": "1K",
})
print("Edit 1:", edit1_url)

# 3. Edit: add a prop
edit2_url = run_job("flux-3-klein-edit-image", {
    "prompt": "Add a small open notebook with a pen to the left of the mug",
    "image_urls": [edit1_url],
    "resolution": "1K",
})
print("Edit 2:", edit2_url)

What this costs

Each call is a separate request at 1K, and each rounds 1.6 credits up to 2. Three calls cost 6 credits, so $0.06 on a monthly plan or $0.09 with top-up credits at $0.015 each. If you finish by rendering the final version at 4K, that last call is 6.5 credits, rounded to 7.

Compare that with doing the same three steps on Flux 2 Pro at 1K: 15 credits. Pro is the better pick for a hero shot where detail matters most, but for iterating, the Klein endpoints let you try about twice as many variations for the same spend.

Making it interactive

To build a real editor on top of this, keep the latest output URL in your app state, send each user instruction to the edit endpoint with that URL, and store every URL so users can step back. Fix the seed on the first generation if you want “regenerate” to produce the same base image. If you build with an AI coding agent, the MCP setup lets Cursor or Claude Code call these models directly while you prototype.

Common mistakes and trade-offs

Most problems people hit with Flux 2 Klein, local or hosted, come from a handful of habits:

• Ignoring the 9B license. The 9B is non-commercial. Building a paid product on it without an agreement is the most expensive mistake on this list.
• Writing vague edit prompts. “Make it better” gives the model nothing to act on. Say what changes and what stays: “change the background to a beach, keep the person and lighting the same”.
• Chaining too many edits. Every edit re-encodes the image, and small artefacts can accumulate over long chains. After five or six edits, regenerate from a cleaner intermediate step or fold several instructions into one edit.
• Generating finals at draft resolution. Iterate at 1K, then render the chosen version once at 2K or 4K. Iterating at 4K costs about four times as much per step for little benefit while you are still deciding.
• Forgetting rounding. Pricing rounds per request. Batching with num_images (for example four 1K images for 7 credits) is cheaper than four single calls at 2 credits each.
• Expecting legible long text. Small models are weaker at rendering paragraphs of text inside images. If your image needs readable labels, GPT Image 1.5 is known for legible text, from 3 credits at low quality.
• Treating Klein as the final-quality model. Klein trades some detail for speed. For a single, carefully lit photoreal image, step up to Flux 2 Pro.

When to choose something other than Klein

Klein is the right default for fast drafts and edit loops. Other options make more sense in a few cases: Nano Banana 2 Lite at 4 credits per image when you want up to 10 reference images for consistency, Flux 2 Pro when photoreal detail is the priority, and the Flux 2 Flex endpoints when you want that tier’s control and are willing to pay 14 credits or more per image. All of them sit in the same model catalog behind the same key, so switching is a one-line change to the model field.

Is Flux 2 Klein worth using?

For most developers, yes, as long as you match it to the job. Flux 2 Klein proved that a small model can handle both generation and editing well enough for real interactive tools, and its 4B Apache 2.0 release made it one of the easiest FLUX models to ship and fine-tune. Run it locally if you want full control, open weights and LoRAs. Use a hosted Klein endpoint if you want the same fast generate-and-edit loop with no GPUs to manage, at 2 credits per 1K image, and keep the bigger FLUX.2 tiers for the final images that need the most detail.