FLUX.1 vs FLUX.2: What Changed and How to Migrate Your API Calls

Black Forest Labs just shipped FLUX.2 — and the gap between it and FLUX.1 is wider than a point release suggests. Multi-reference editing, hex color steering, sub-second generation, and real-time grounding search are all new. If you're running FLUX in production, here's what changed and what you'll need to update in your API calls.

The FLUX Model Progression: A Quick Recap

Before getting into FLUX.2 specifically, it helps to understand the full family tree. Black Forest Labs released models in this order:

• FLUX.1 [dev] — open weights, non-commercial license, research use
• FLUX.1 [schnell] — open weights, Apache 2.0, fast inference
• FLUX.1 [pro] — commercial API, highest quality in the first generation
• FLUX 1.1 [pro] — 6× faster than FLUX.1 [pro], same quality
• FLUX 1.1 [pro] Ultra — adds 4MP output and Raw mode for photography aesthetics
• FLUX.1 Kontext — text-to-image plus powerful in-context editing (change objects, colors, text via natural language)
• FLUX.2 — current flagship; combines generation with multi-reference editing

FLUX.2 isn't just a quality bump. It introduces a fundamentally different workflow capability: feeding multiple reference images into a single generation call.

What's New in FLUX.2

Multi-Reference Editing (Up to 10 Sources)

This is the headline feature. FLUX.2 can accept up to 10 reference images in a single request and combine elements from all of them while maintaining consistent identity across the output. The practical use cases are significant:

• Character consistency at scale — fashion editorials with 8 consistent characters, all sourced from reference shots
• Product mockups in any context — reference a product + a scene + a brand style separately
• Ad variant creation — keep a specific face consistent across multiple backgrounds and compositions
• Combined pose and character guidance — reference a character from one image and a pose from another

This eliminates a common multi-step workflow where developers had to generate, then use inpainting or face-swap pipelines to maintain consistency. FLUX.2 handles it in one call.

Hex Color Steering

FLUX.2 accepts hex color codes as direct generation parameters. Instead of writing "a product on a muted sage green background" and hoping the model interprets it correctly, you specify #8FBC8F and get precisely that color. This is particularly useful for brand compliance in e-commerce and product photography workflows.

Grounding Search (FLUX.2 [max] Only)

FLUX.2 [max] can search the web in real time before generating. You can ask for a visualization of a current sports score, today's weather in a specific city, or a historical event at a specific location and date — and the model grounds its output in actual retrieved data rather than training-data approximations.

FLUX.2 [klein] — Open Weights, Sub-Second Inference

The [klein] variant is open weights under Apache 2.0 (or FLUX Non-Commercial for non-commercial use). It's designed for real-time, high-volume generation where latency matters more than maximum quality. If you're running an application that needs sub-second generation — live previews, interactive tools, batch processing at scale — [klein] is the variant to use.

Improved Photorealism

Hands, faces, small text, and complex textures were the consistent weak points of FLUX.1 and earlier diffusion models. FLUX.2 closes that gap significantly. According to BFL's documentation, accurate hand rendering, facial detail, fabric texture, logos, and small objects are all improved — making outputs harder to distinguish from real photography, which matters for e-commerce and product visualization.

Typography

FLUX.2 renders readable text reliably. This enables new use cases: generating production-ready ad creatives with legible headlines, UI mockups with correct copy, magazine layouts, infographics with actual data labels. If you've tried this with earlier models and hit the "text soup" problem, it's worth re-testing with FLUX.2.

FLUX.2 Variants: Which One to Use

API Migration: FLUX.1 to FLUX.2 via ModelsLab

ModelsLab exposes FLUX models through its unified text-to-image endpoint. Here's what a standard FLUX.1 call looks like:

import requests

response = requests.post(
    "https://modelslab.com/api/v6/images/text2img",
    json={
        "key": "YOUR_API_KEY",
        "model_id": "flux",
        "prompt": "a product shot of a ceramic coffee mug on a wooden table, soft morning light, photorealistic",
        "negative_prompt": "blurry, low quality, distorted",
        "width": 1024,
        "height": 1024,
        "num_inference_steps": 30,
        "guidance_scale": 7.5,
        "seed": 42
    }
)

data = response.json()
print(data["output"][0])  # URL of generated image

The core request structure stays the same when you move to FLUX.2. The model_id changes to target the updated variant, and you gain access to new optional parameters:

import requests

# FLUX.2 call — same endpoint, updated model_id + optional new params
response = requests.post(
    "https://modelslab.com/api/v6/images/text2img",
    json={
        "key": "YOUR_API_KEY",
        "model_id": "flux2",          # Updated model identifier
        "prompt": "a product shot of a ceramic coffee mug on a wooden table, soft morning light, photorealistic, #8B4513 wooden surface",
        "negative_prompt": "blurry, low quality",
        "width": 1024,
        "height": 1024,
        "num_inference_steps": 30,
        "guidance_scale": 7.5,
        "seed": 42,
        # Multi-reference (FLUX.2 new param):
        # "reference_images": ["https://...", "https://..."],
    }
)

data = response.json()
print(data["output"][0])

The major behavior change to test for:

• Prompt interpretation: FLUX.2 follows prompts more literally, especially for spatial composition. Prompts that worked loosely in FLUX.1 may render more precisely than expected — review your prompt library.
• Negative prompts: FLUX architecture processes negative prompts differently from older diffusion models. They work, but the interaction is more about structural quality than style exclusion.
• Guidance scale: You may need to recalibrate. Start at 3.5–4.5 for FLUX models (lower than the 7.5 default that works for Stable Diffusion).
• Steps: FLUX is efficient. 20–30 steps typically gives you the full quality benefit; going higher rarely improves results.

Practical Migration Checklist

If you're moving an existing FLUX.1 integration to FLUX.2:

1. Update model_id — swap "flux" for "flux2" (or the specific variant: "flux2-pro", "flux2-max")
2. Lower guidance scale — try 3.5–4.5 if you were using 7+ for Stable Diffusion
3. Review prompt library — FLUX.2 is more literal; remove vague qualifiers that padded FLUX.1 prompts
4. Test edge cases — hands, text in images, fine fabric textures (these improve significantly in FLUX.2)
5. Enable multi-reference if applicable — if your use case involves character consistency or product context shots, the multi-reference param replaces multi-step pipelines
6. Check output resolution — FLUX.2 can push toward 4MP; update downstream image handling if you're enforcing strict dimensions

What the New Features Enable for Developers

E-Commerce Product Photography

Before FLUX.2, placing a product consistently across multiple lifestyle contexts required separate passes and often manual compositing. With multi-reference, you reference the product and the desired scene; FLUX.2 handles lighting, shadow, and perspective matching in one generation. Pair this with hex color steering and you can enforce brand palette compliance on every output.

Character-Consistent Content at Scale

Apps that generate personalized content — branded avatars, custom illustrations, marketing materials with specific individuals — previously needed fine-tuned LoRA models or complex face-swap post-processing. Multi-reference makes this a direct API feature: send reference images, describe the scene, get consistent output.

Real-Time Grounded Visuals

The grounding search capability in [max] opens a new category of application: visualizations of current events, real-time data, or location-specific context. Sports score graphics, weather visualization, live event photography-style renders. Previously, this required retrieval-augmented generation (RAG) architectures with separate LLM + image generation pipelines. It's now a parameter.

Text-Heavy Design Generation

Marketing teams can now use AI generation for ad creatives with actual readable copy, UI wireframes with correct labels, and infographic drafts with real data. The typography improvement in FLUX.2 is enough that these use cases go from "prototype only" to "production-ready."

Getting Started with FLUX.2 via ModelsLab

ModelsLab's API covers the full FLUX family, including FLUX.2 variants, through a single unified endpoint. You get pay-per-call pricing, no infrastructure management, webhook support for async generation, and the same key across all models. This means you can test FLUX.2 alongside your existing FLUX.1 calls without switching API providers.

# Quick curl test
curl -X POST https://modelslab.com/api/v6/images/text2img \
  -H "Content-Type: application/json" \
  -d '{
    "key": "YOUR_API_KEY",
    "model_id": "flux2",
    "prompt": "minimalist product photography, a white ceramic mug with geometric pattern, studio lighting, clean background",
    "width": 1024,
    "height": 1024,
    "num_inference_steps": 28,
    "guidance_scale": 4.0,
    "seed": 42
  }'

You can get an API key from the ModelsLab dashboard — there's a free tier to test with before you commit to production volume.

Key Takeaway

FLUX.2 is a significant enough upgrade that it warrants a proper migration and re-evaluation of how you're using the API — not just a model_id swap. Multi-reference editing, in particular, eliminates entire workflow steps for consistency-dependent use cases. The [klein] variant makes real-time generation viable for apps where sub-second latency was previously a blocker. And the typography improvements alone open up product categories that weren't feasible with earlier generation image models.

Start with a side-by-side comparison on your existing prompts, recalibrate guidance scale, and then experiment with the new parameters. The migration is low-friction; the capability jump is real.