How to Fine-Tune FLUX With an API: When It Pays, Which Model, What It Costs

Generating one good image is solved. Generating the same product, the same face or the same illustration style in the five-hundredth image is not. A text prompt describes a subject in words, and words leave room: the label shifts, the jawline changes, the brand's flat pastel style drifts toward the model's own default look. Consistency is where generative imagery stops being a demo and becomes a production system, and it is the problem fine-tuning solves.

This guide covers why teams fine-tune an image model, when they don't need to, why FLUX is the usual base, which FLUX version to train on, and the data, cost and code for doing it through an API.

The problems fine-tuning solves

Teams that ship images at volume need one subject or look held fixed while everything else changes. Photoshoots and manual retouching hold it fixed, but they cost the same for the hundredth image as for the first. Reference images help, but they are another input to manage on every call, and the result can still drift. Fine-tuning moves the subject into the model, so a short text prompt is enough to bring it back.

The patterns that come up most:

• Product catalogs. A retailer needs each product in lifestyle scenes, seasonal backdrops and every ad format, with the label, shape and colour exact.
• Brand style. A marketing team wants every campaign asset in the house illustration style, whoever writes the prompt.
• Characters. A game studio or a children's-book app needs the same character in hundreds of scenes, poses and expressions.
• Personalized avatars. A consumer app trains one small adapter per user from a few selfies and generates that person in new settings.
• Repeatable edits. A marketplace needs every seller photo cut out and placed on the brand's backdrop, with the same light, every time.
• House photo look. A real-estate or food platform wants all generated imagery to share one grade, lens feel and composition.

What a LoRA is, in plain words

Full fine-tuning rewrites every weight of the base model and produces a new multi-gigabyte model you then have to host. A LoRA (low-rank adaptation) instead trains a small set of extra weights that sit beside the frozen base model and nudge its output toward your subject or style.

That makes it the practical form of fine-tuning:

• Small. The result is a single .safetensors file, a fraction of the base model's size.
• Cheap. A run on a hosted trainer costs a few dollars and finishes without you managing a GPU.
• Swappable per request. The LoRA endpoints in this guide take the file's URL on each call, so one endpoint can serve a different LoRA per customer, brand or campaign. The FLUX 3 Image Klein LoRA endpoints accept up to three at once, each with its own strength from 0 to 4.¹
• Base model unchanged. You keep the base model's general skills and switch the LoRA off for everything else.

The limit is that a LoRA only works on the base model it was trained against. Choosing that base model is the decision that lasts.

Do you need to fine-tune at all?

Not always. Recent FLUX models can hold a subject from a reference image with no training. Black Forest Labs describes FLUX.2 [dev] as doing "character, object and style reference without additional training in one model",² and FLUX.1 Kontext [dev] as able to "have character, style and object reference without any finetuning".³ FLUX 3 Image Klein takes up to 10 reference images per request.⁴

A practical rule:

• Start with reference-image editing for a few images, a one-off campaign, or a subject that changes every week. Pass the reference to an edit endpoint and iterate on the prompt.
• Fine-tune when one of these holds:
  • The same identity or style must stay locked across hundreds or thousands of images.
  • You need it from text-only prompts, with no reference image to manage per call.
  • Exact product details matter: label text, logo placement, stitching, proportions.
  • Reference editing drifts after a few generations or across scene changes.

The two also combine. An edit LoRA trained on your before-and-after pairs makes a reference-image workflow repeatable.

Why FLUX is the usual base

• Open weights you can adapt. Black Forest Labs publishes the weights. FLUX.1 [dev] is a 12-billion-parameter rectified flow transformer for text-to-image.⁵ FLUX.2 [dev] is 32 billion parameters and handles generation plus single- and multi-reference editing.² FLUX.1 Kontext [dev] is a 12-billion-parameter model for instruction editing.³ FLUX 3 Image Klein is a 5.6-billion-parameter model for generation and editing, with a separate undistilled base checkpoint for "fine-tuning, LoRA training and research".⁴
• A large LoRA ecosystem. Hugging Face lists more than 40,000 adapters built on FLUX.1 [dev].⁵ Black Forest Labs calls it "the most popular open image model globally".⁶ Training tools and ComfyUI workflows already target it.
• Capabilities that brand work needs. Black Forest Labs designed FLUX.2 for "reading and writing complex text, adhering to brand guidelines, and reliably handling lighting, layouts, and logos".⁶ In its own evaluations, FLUX 3 Image Klein ranks first among open-weights models in text-to-image, multi-reference generation and editing, with 91 Elo over FLUX.2 [klein] 9B in text-to-image.⁷
• Hosted trainers and LoRA endpoints. On fal, every FLUX generation in this guide has a trainer and a matching LoRA inference endpoint, so the whole loop is two API calls.

When another base model fits better: if your product already serves another open model, train on that one, because the LoRA has to match it. fal also hosts trainers for Qwen-Image and Z-Image Turbo. For video, see How to fine-tune Wan with the API.

Which FLUX to train on

The names overlap, so first the map. "FLUX 3" on its own is Black Forest Labs' video model, which fal serves at endpoints such as blackforestlabs/flux-3/text-to-video. FLUX 3 Image Klein is the open 5.6B image model released in October 2026, shipped as a distilled checkpoint for fast generation and a base checkpoint for training.⁴⁷ FLUX.2 [klein] is the earlier 4B and 9B FLUX.2 family. They are different models, and their LoRAs are not interchangeable.

Our recommendation: start new work on FLUX 3 Image Klein. Stay on FLUX.1 [dev] if your product already depends on its LoRAs or tools. Use FLUX.2 [dev] when Klein's quality is not enough for your subject and the higher per-image price is acceptable.

The trainers, their LoRA endpoints and default prices:

Prices are from each trainer's model page.^891011121314 FLUX.2 [klein] trainers also exist, fal-ai/flux-2-klein-9b-base-trainer and fal-ai/flux-2-klein-4b-base-trainer.¹⁵

Each FLUX 3 Image Klein LoRA has two serving options. The base endpoints run the undistilled model with guidance, which the trainer page recommends. The distilled endpoints are step-distilled for speed and cost about a third as much.¹¹⁴ Generate the same test prompts on both, and serve distilled if your subject holds.

Prepare a dataset the trainer can read

Every trainer takes one zip file by URL. The naming rules decide whether the job runs at all.

Pairs on the Klein edit trainer may have different numbers of inputs, and the price multiplier rises with the inputs per pair.¹³ The FLUX 3 Image Klein trainers also take a resolution of 512, 768 or 1024 (the default), keeping each image's aspect ratio.¹⁴

What changes the result:

• Count. The FLUX.1 fast trainer needs at least 4 images; the portrait and FLUX.2 trainers ask for 10 or more.⁸⁹¹⁰ For a style, 9 to 50 images is typical.¹⁰ Consistency matters more than volume.
• Resolution. Use 1024x1024 or larger, with no compression artifacts.⁸¹⁰ Crop out watermarks and borders, or the LoRA learns them.
• Vary what you do not want learned. If every product shot has the same backdrop, the LoRA reproduces the backdrop.
• Caption the parts that change. Describe setting, pose and light, and name the subject only by its trigger token, so the token binds to what stays constant. FLUX 3 Image Klein is trained on detailed captions, so write full sentences.¹
• Pick a token that means nothing yet, such as ACMEBOTTLE.

Price the steps before you run

All these trainers bill per step, so you can price a run before you submit it.

FLUX 3 Image Klein bills $0.0043 per step with a 100-step minimum.¹⁴ Its edit trainer bills $0.002 per step times a multiplier for the inputs per pair: 2.11 with one, 6.95 with four, up to 23.44 with ten.¹³ The portrait trainer charges a $2.40 minimum and Kontext requires at least 500 steps.⁹¹¹

Because runs are cheap, train three step counts in parallel and compare, rather than iterating one run at a time. A 500 / 1,000 / 2,000 sweep costs $15.05 on FLUX 3 Image Klein, $7.00 on the FLUX.1 fast trainer and $22.40 on FLUX.2 [dev]. Too few steps and the subject does not stick; too many and outputs copy the training set.

Train and generate in Python

Install the client and set your key:

pip install fal-client
export FAL_KEY="your-api-key"

Training is a queued job. Submit it, store the request ID so a restart does not lose the job, and fetch the result when the status is Completed.

import time
import fal_client

TRAINER = "blackforestlabs/flux-3/klein/base/trainer"

# 1. Upload the dataset to fal storage
dataset_url = fal_client.upload_file("dataset.zip")

# 2. Submit the training job
handle = fal_client.submit(
    TRAINER,
    arguments={
        "images_data_url": dataset_url,
        "trigger_phrase": "a photo of ACMEBOTTLE",
        "steps": 1000,
    },
)
request_id = handle.request_id
print("training request:", request_id)

# 3. Poll until the job completes
while True:
    status = fal_client.status(TRAINER, request_id, with_logs=True)
    if isinstance(status, fal_client.InProgress) and status.logs:
        print(status.logs[-1]["message"])
    if isinstance(status, fal_client.Completed):
        break
    time.sleep(15)

training = fal_client.result(TRAINER, request_id)
lora_url = training["lora_file"]["url"]
print("LoRA:", lora_url)

# 4. Generate with the LoRA
image = fal_client.subscribe(
    "blackforestlabs/flux-3/klein/base/text-to-image/lora",
    arguments={
        "prompt": "ACMEBOTTLE on a marble kitchen counter, morning light from a window on the left, shallow depth of field, product photo",
        "loras": [{"path": lora_url, "scale": 1.0}],
        "image_size": {"width": 1024, "height": 768},
        "seed": 42,
    },
)
print(image["images"][0]["url"])

In production, replace the polling loop with a webhook: pass webhook_url to fal_client.submit and fal calls your server when training ends.¹⁶ The trainer returns lora_file, the weights, and config_file, the training configuration.¹⁴

The Klein endpoints expand short prompts into a full caption by default (enable_prompt_expansion). If outputs lose the subject, write the full caption yourself, with the trigger token in it, and set enable_prompt_expansion to false.¹

To train on another FLUX, the field names change:

Serve FLUX.1 LoRAs with fal-ai/flux-lora and FLUX.2 LoRAs with fal-ai/flux-2/lora, which takes up to three LoRAs per request and also accepts a Hugging Face repo ID as the path.¹⁷¹⁸ The FLUX.2 and Kontext trainers can write ComfyUI key names: set output_lora_format to comfy.¹⁰¹¹

The same calls from Node

import { readFile } from "node:fs/promises";
import { fal } from "@fal-ai/client";

const TRAINER = "blackforestlabs/flux-3/klein/base/trainer";

const zip = new File([await readFile("dataset.zip")], "dataset.zip", {
  type: "application/zip",
});
const datasetUrl = await fal.storage.upload(zip);

const { request_id } = await fal.queue.submit(TRAINER, {
  input: { images_data_url: datasetUrl, trigger_phrase: "a photo of ACMEBOTTLE", steps: 1000 },
  webhookUrl: "https://your-app.example.com/fal/training-done",
});

// Later, in your webhook handler or a status check:
const training = await fal.queue.result(TRAINER, { requestId: request_id });
const loraUrl = training.data.lora_file.url;

const image = await fal.subscribe("blackforestlabs/flux-3/klein/text-to-image/lora", {
  input: {
    prompt: "ACMEBOTTLE on a marble kitchen counter, morning light from a window on the left, product photo",
    loras: [{ path: loraUrl, scale: 1.0 }],
  },
});
console.log(image.data.images[0].url);

Call fal from your server, not from the browser, so your key stays private.

What training plus 1,000 images costs

Training is paid once. Inference is paid on every image. This table prices one default training run plus 1,000 images at one megapixel each.

Inference prices are from the endpoint pages.¹¹⁷¹⁸ Klein on the distilled endpoint costs $2.30 more to train than the FLUX.1 fast trainer and $0.023 less per image, so it is the cheaper path from 100 images on. Against FLUX.2 [dev] it is cheaper on both lines. If you expect volume, choose the base model by its per-image price and output quality, not by its training price.

Three details move the inference bill:

• The Klein LoRA endpoints count any image up to 1024x1024 as one megapixel and a 2048x2048 image as 1.56, so large outputs cost less per pixel.¹
• fal-ai/flux-lora rounds each image up to the nearest megapixel. An image a little over 1 MP bills as 2 MP, which doubles its cost.¹⁸
• On fal-ai/flux-2/lora, LoRAs larger than 2 GB in total add 50% per extra GB, up to a 5 GB limit.¹⁷

Where the LoRA goes next

A trained FLUX LoRA is a file URL, not an endpoint. The hosted LoRA endpoints above load it on each request, so you can serve a different LoRA per customer or brand with nothing to deploy. When you need your own code around the model, many adapters behind one endpoint, or a base model fal does not host a trainer for, see How to Deploy a LoRA as an API.

FAQ

Is FLUX 3 Image Klein the same as FLUX.2 [klein]?

No. FLUX.2 [klein] is the earlier 4B and 9B family. FLUX 3 Image Klein is a separate 5.6B model, and a LoRA trained on one does not work on the other.⁴

What is the cheapest way to fine-tune FLUX through an API?

The FLUX.1 fast trainer has the lowest training price, $2.00 for 1,000 steps.⁸ Over a production run, FLUX 3 Image Klein on its distilled LoRA endpoint costs less from about 100 images on, at $0.012 per megapixel.¹

Why did my training job fail at once?

Most often, captions are missing. The FLUX.2 trainers need a .txt caption per image or a default_caption, and the FLUX 3 Image Klein trainers need trigger_phrase when any image lacks a caption.¹⁰¹⁴ Also check the dataset field: FLUX.2 uses image_data_url; the others use images_data_url.

Can I reuse a FLUX.1 LoRA on FLUX.2 or FLUX 3 Image Klein?

No. A LoRA changes the weights of one model. Train again on the new base with the same dataset.

References