FLUX 3 Image Klein

A smaller, faster FLUX 3 Image model with open weights. Run it through the API, on Hugging Face, or in ComfyUI.

FLUX 3 Image

Klein

FLUX 3 Image Klein is a compact, open-weights version of FLUX 3 Image. It supports the same features: text to image, image editing, multi reference, and bounding boxes. It runs faster and fits on consumer GPUs, down to an RTX 3090. Do not use it without its prompt upsampler.

Specs

FLUX 3 Image Klein comes in two variants. Distilled is step-distilled for fast inference. Base is the undistilled model for fine-tuning, LoRA training, and research.

	Klein (Distilled)	Klein Base
Parameters	5.6B	5.6B
Max resolution	Up to 4K	Up to 4K
Inference steps	16	50
Guidance (CFG)	1	3.5
Bounding box support	Yes	Yes
Best for	Fast generation, local deployment	Fine-tuning, LoRA training, research
License	FLUX Kommunity License	FLUX Kommunity License
Availability	API, Hugging Face	Hugging Face

Pricing

Priced per image by output resolution. Text to image and image editing cost the same.

Resolution	Price per image
768 × 768	$0.008
1K	$0.009
1.5K	$0.011
2K	$0.014
4K	$0.036

See API pricing for all models.

Ways to use it

Do not use Klein without the prompt upsampler. The model is trained on the captions it writes; a prompt sent as typed gives noticeably weaker results.

API

Send a request to the Klein endpoint, then poll the returned polling_url until status is Ready. The request takes the same fields as FLUX 3 Image.

curl --request POST \
  --url https://api.bfl.ai/v1/flux-3-image-klein \
  --header "x-key: $BFL_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
  "prompt": "A red fox curled up asleep inside an open vintage leather suitcase on the luggage rack of an old wooden train compartment, soft window light falling on its fur, photorealistic.",
  "aspect_ratio": "4:3"
}'

See the API reference for all parameters.

Diffusers / Hugging Face

Download the FLUX 3 Image Klein weights from Hugging Face and run them locally with Diffusers.

The pipeline does not call the prompt upsampler. Do not send it a prompt as typed: the prompt below is a full caption, anything shorter goes through the upsampler first.

pip install git+https://github.com/huggingface/diffusers.git

import torch
from diffusers import ModularPipeline

pipe = ModularPipeline.from_pretrained("black-forest-labs/flux-3-image-klein")
pipe.load_components(dtype=torch.bfloat16)
pipe.to("cuda")

image = pipe(
    prompt=(
        "A red fox curled up asleep inside an open vintage leather suitcase on the luggage rack "
        "of an old wooden train compartment, soft window light falling on its fur, photorealistic."
    ),
    generator=torch.Generator().manual_seed(0),
    output="images",
)[0]
image.save("klein.png")

For fine-tuning and LoRA training, use the Base weights (black-forest-labs/flux-3-image-klein-base).

ComfyUI

Run FLUX 3 Image Klein in ComfyUI with a ready-made workflow.

1. Update ComfyUI to the latest version.
2. Download the Klein weights from Hugging Face.
3. Load the Klein workflow from the ComfyUI Klein page and enter your prompt.

Prompt upsampling

Klein is trained on full scene captions. The prompt upsampler (black-forest-labs/flux-3-image-klein-pup) rewrites a short prompt or a one-line edit instruction, together with any reference images, into that kind of caption before generation.

• Reference code: the CLI runs it by default. Don’t pass --no-pup unless you write full captions yourself.
• Diffusers: it’s a separate model that the pipeline does not call. Run it with Transformers and pass its output to the pipeline as prompt. It adds about 28 GB of GPU memory.

import json

import torch
from huggingface_hub import hf_hub_download
from transformers import AutoProcessor, Qwen3_5ForConditionalGeneration

pup_id = "black-forest-labs/flux-3-image-klein-pup"
processor = AutoProcessor.from_pretrained(pup_id)
upsampler = Qwen3_5ForConditionalGeneration.from_pretrained(pup_id, dtype=torch.bfloat16, device_map="auto").eval()
system_prompts = json.load(open(hf_hub_download(pup_id, "system_prompts.json")))


def upsample(prompt, images=()):
    if images:
        text = (
            "Reference images follow in order (the first image, the second image, ...).\n"
            f"User request: {prompt}\nOutput the caption."
        )
        content = [{"type": "image", "image": image} for image in images] + [{"type": "text", "text": text}]
        messages = [{"role": "system", "content": system_prompts["i2i"]}, {"role": "user", "content": content}]
    else:
        messages = [{"role": "system", "content": system_prompts["t2i"]}, {"role": "user", "content": prompt}]
    inputs = processor.apply_chat_template(
        messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", enable_thinking=False
    ).to(upsampler.device)
    with torch.no_grad():
        output = upsampler.generate(**inputs, max_new_tokens=3584, do_sample=False)
    return processor.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True).strip()


# pipe is the pipeline from the Diffusers tab above
image = pipe(prompt=upsample("A red fox asleep in a suitcase on a train"), output="images")[0]

For an edit, pass the same reference images to both: pipe(prompt=upsample(instruction, [image]), image=image, ...). The upsampler also writes the layout captions from a list of boxes; see its model card.

If you skip it, write full scene captions yourself: framing, subject, background and lighting.

Text to image

Photography, illustration, and typography from a single prompt. Click any image to view it full size.

Edit an image

Write the change as an instruction. Drag the handle to compare each source with its edit:

Train a LoRA

LoRA training lets you personalize Klein to your own brand guidelines, products, characters or visual styles. Train LoRAs on Klein Base. A rank-32 LoRA trained on a handful of images on a single GPU is enough to teach Klein a new style or edit. The trained LoRA can also run on Klein Distilled.

AI Toolkit

Training suite with a GUI and CLI. Supports both text-to-image and edit LoRAs.

Diffusers

Hugging Face training scripts for DreamBooth and LoRA.

Training config

Setting	Value
Base model	Klein Base
Dataset	20 images, captions end with the trigger shtm style
Resolution	~1 MP, native aspect ratio
LoRA rank / alpha	32 / 32
Optimizer	AdamW, betas (0.9, 0.95)
Learning rate	1e-4, 200 warmup steps, then linear decay
Steps	4000, checkpoint every 250
Hardware	1 GPU, about 4.5 hours

The same settings as an AI Toolkit config (select FLUX.3 Image Klein (base) in the UI, or arch: flux3):

job: extension
config:
  name: klein-miniature-lora
  process:
    - type: diffusion_trainer
      training_folder: output
      device: cuda:0
      network:
        type: lora
        linear: 32
        linear_alpha: 32
      save:
        dtype: bf16
        save_every: 250
      datasets:
        - folder_path: data/miniature         # images + .txt captions ending in "shtm style"
          caption_ext: txt
          resolution: [1024]
      train:
        batch_size: 1
        steps: 4000
        lr: 1e-4
        optimizer: adamw
        dtype: bf16
      model:
        name_or_path: black-forest-labs/flux-3-image-klein-base
        arch: flux3

Example: Persian miniature LoRA

We trained a style LoRA on 20 public-domain paintings from the 16th-century Shahnameh of Shah Tahmasp. Captions describe only the content and end with the trigger shtm style.

Six of the 20 training images:

Example caption:

A crowned ruler in a green robe sits on a throne inside an ornate tiled palace hall, attended by courtiers and guards while musicians sit in the foreground. In a narrow panel at the right, grooms and soldiers stand among horses and decorated elephants in a flowering landscape. shtm style

Base vs. LoRA at step 1500, same prompt and seed.

Run a LoRA on Klein Distilled

Klein Base and Klein Distilled share the same architecture, so a LoRA trained on Base loads into Distilled without any conversion. Train on Base, then generate with Distilled at 16 steps instead of 50.

Keep Distilled’s sampler settings and lower the LoRA scale slightly. In our tests 0.75 matched the Base + LoRA result most closely, and anything from 0.5 to 1.0 works.

Setting	Value
Steps	16
Guidance (CFG)	1
LoRA scale	0.75 (0.5 to 1.0)

The style or edit comes through as strongly as on Base. Distilled renders the same seed differently, so expect small changes in details like a hair color or the phase of the moon, not in the style itself.

Two style LoRAs trained on Base, run on Base at 50 steps and on Distilled at 16 steps. Same prompt and seed.