Flux 2 Complete Guide: Black Forest Labs' Photorealistic AI Image Models

Flux 2 has expanded what’s possible in AI image generation. From the team behind the original Stable Diffusion research comes a family of models focused on photorealistic images, text rendering, and practical creative workflows. Whether you’re a designer, developer, marketer, or content creator, understanding Flux 2’s capabilities can help you choose the right model for the job.

This guide covers Flux 2’s architecture, variant comparisons, practical implementation, and real-world use cases. By the end, you’ll know which model fits your needs and how to get started.

What is Flux 2?

Flux 2 is the second-generation image generation family from Black Forest Labs, the German AI research company founded by members of the original Stable Diffusion team. Released in November 2025, Flux 2 supports text-to-image generation and image editing.

One important distinction: the 32-billion-parameter description belongs to the open-weight Flux 2 ​Dev model. It shouldn’t be applied to every Max, Flex, and Pro endpoint. Black Forest Labs describes the wider family in terms of different production goals, including maximum quality, fine-grained control, and high-volume use. Its Flux 2 overview is the best place to check the current lineup.

The result? A set of models you can use for product visuals, campaign concepts, typography-heavy mockups, and edits based on existing images. The final asset still deserves a human check, especially when product details or written text must be exact.

Key Innovation: Flow Matching Architecture

Traditional image diffusion workflows iteratively transform noise into an image. Flux 2 Dev uses a rectified-flow transformer, according to its official model card. For a creator, the useful questions are more concrete:

• ​Prompt adherence​: Does the image include the requested subjects, relationships, and layout?
• ​Consistency​: Can a reference image help preserve the same product or character across edits?
• ​Detail​: Do materials, small labels, and edges hold up at the output size you need?
• ​Control​: Does the endpoint expose the settings your workflow requires?

Architecture alone doesn’t establish a speed or quality ranking. Those comparisons need a dated benchmark, a named endpoint, and matching test conditions.

Black Forest Labs: The Team Behind Flux 2

Understanding Black Forest Labs helps explain the design choices behind Flux 2. The company includes researchers associated with the original Stable Diffusion work and publishes both commercial API models and open-weight releases.

That combination matters in practice:

• Cloud ​API​​ access for teams that want to generate and edit without running the model locally
• Open-weight tooling for developers who need to inspect or adapt a local workflow
• Multiple variants for different quality, cost, and control requirements
• Image editing and references alongside text-to-image generation

The official Flux 2 inference repository provides the clearest starting point for local tooling. Check the license attached to the weights separately from the license on repository code.

Flux 2 Variants: Complete Comparison

Black Forest Labs offers Max, Flex, Pro, and Dev for different use cases. This guide keeps those four as its focus. The wider Flux 2 family may grow, so check the current catalog before treating this list as exhaustive.

I have removed the original LM Arena positions and scores: they had no dated snapshot or source, and a current ranking could have changed since the article was drafted.

Flux 2 Max: Maximum Quality

Flux 2 Max is positioned for the highest-quality work in this group, particularly assets where detail and prompt following matter more than the lowest possible cost.

​Key Strengths​:

• Photorealism for lighting, composition, and material rendering
• Text rendering for mockups and graphics that include short written elements
• Reference-based editing when an existing image needs a careful transformation
• High-resolution​ output within the selected endpoint’s limits

​Best For​:

• Marketing campaigns requiring polished hero assets
• High-end product visualization
• Print concepts that need room for later layout work
• Client-facing images where visible errors are expensive
• Creative pipelines that can budget for extra review

​Pricing on WaveSpeedAI​: The Max text-to-image page listed $0.07 per generated image when checked on November 1, 2026. Confirm the live price and selected output settings before budgeting a batch.

​When to Choose Max​: If you’re producing a hero image or another detail-critical asset, start here and check the output at full size. “Maximum quality” is a model position, not a guarantee that every render will be usable.

Flux 2 Flex: Balanced Performance

Flux 2 Flex is aimed at creative exploration and fine-grained control. It can be useful when you’re moving between product photography, illustration, and typography-heavy concepts.

​Key Strengths​:

• Stylistic versatility across different visual directions
• Fine-grained control where the particular provider exposes the relevant settings
• Creative iteration for comparing prompts and compositions
• Text-focused work that benefits from careful review and revision

A provider’s model page matters here. Black Forest Labs may expose controls that a hosted WaveSpeedAI endpoint does not. Don’t assume that a setting shown in one provider’s API can be sent to another provider’s endpoint.

​Best For​:

• Design agencies serving clients with different aesthetics
• Creative exploration and concept development
• Teams comparing several prompt directions
• Developers who need a configurable workflow
• Projects where typography is a visible part of the image

​Pricing on WaveSpeedAI​: The Flex text-to-image page listed $0.06 per generated image on November 1, 2026.

​When to Choose Flex​: If you need to explore creative directions or want more control over how a model behaves, compare the exact controls available through your chosen provider.

Flux 2 Pro: Production Optimized

Flux 2 Pro is positioned as a practical production choice: a straightforward text-to-image endpoint, with editing available through a separate endpoint.

​Key Strengths​:

• Production-oriented generation without requiring step or guidance tuning
• Prompt-based image editing through a dedicated edit route
• Reference-image workflows for products, people, or visual direction
• Photorealistic output for commercial concepts and asset preparation

Reference limits depend on where you run it. Black Forest Labs documents ​up to eight input references through its direct ​API​. WaveSpeedAI’s Flux 2 ​Pro​​ Edit endpoint currently accepts ​up to three image URLs​. Use the limit for the endpoint you’re actually calling.

​Best For​:

• E-commerce product visualization
• Brand asset creation
• Automated generation and editing workflows
• API integrations for production applications
• Teams that prefer a smaller set of exposed controls

​Pricing on WaveSpeedAI​: The Pro text-to-image page listed $0.03 per generated image on November 1, 2026. Pro Edit was listed separately at ​**$0.06 per edited image**​.

​When to Choose ​Pro​: If you’re building a repeatable production workflow, Pro is a reasonable starting point. Check the cost and input limits of generation and editing separately.

Flux 2 Dev: Developer Foundation

Flux 2 Dev is the open-weight option for developers, researchers, and teams building custom solutions. “Dev” does not mean the underlying model is small: its official model card describes a 32B-parameter model.

​Key Strengths​:

• Open weights for local inference and experimentation
• Tooling access for inspecting and adapting workflows
• Generation and editing within supported local pipelines
• A foundation for research and custom development

​Best For​:

• Local experimentation
• Research and prototype workflows
• Teams evaluating self-hosting
• Developers learning the Flux 2 architecture
• Custom pipelines where model access matters

​Pricing on WaveSpeedAI​: The hosted Dev text-to-image endpoint listed $0.012 per generated image on November 1, 2026. That is WaveSpeedAI’s hosted offer; Black Forest Labs’ own pricing page lists Dev as a local model, not one of its hosted API endpoints.

​When to Choose Dev​: If you need the weights or want a low-cost hosted starting point, Dev is useful. For self-hosting, read the Flux 2 Dev model card and license before planning commercial training or deployment.

Variant Comparison Table

Feature	Max	Flex	Pro	Dev
Primary use	Detail-critical assets	Creative control	Production workflows	Open-weight development
Model access	Hosted	Hosted	Hosted	Open weights; also hosted by some providers
Text-to-image price on WaveSpeedAI*	$0.07	$0.06	$0.03	$0.01
Image editing	Separate edit route	Separate edit route	Separate edit route	Local tooling or provider-specific route
Good starting point for	Hero assets	Creative work	Repeatable production	Local experiments

*WaveSpeedAI text-to-image prices checked November 1, 2026. Editing prices and Black Forest Labs’ direct API pricing follow their own schedules. The original table’s LM Arena ranks and scores were removed because they lacked a dated source.

Key Features and Capabilities

1. Photorealistic Image Generation

Flux 2 is designed for photorealistic generation. Rather than assuming every output is production-ready, inspect the parts that are easiest to miss:

​Human Subjects​:

• Skin texture and facial anatomy
• Hair against complex backgrounds
• Eye reflections and expressions
• Hands and finger positioning

​Lighting and Atmosphere​:

• Light direction and shadow placement
• Depth of field and bokeh
• Color temperature
• Fog, mist, and other volumetric effects
• Studio lighting for product photography

​Materials and Textures​:

• Glass transparency and reflections
• Metallic surfaces
• Fabric texture
• Wood grain and natural materials
• Liquids and packaging finishes

​Environmental​ Coherence​:

• Object scale and perspective
• Architectural details
• Landscape depth
• Placement of products in the scene

These checks matter for the same applications the original article identified:

• Product photography concepts
• Stock-style imagery
• Marketing campaign visuals
• Social media content
• Credible conceptual mockups

2. Revolutionary Text Rendering

Text rendering has long been difficult for image generators. Flux 2 supports typography-heavy work, but the original “60% accuracy on first attempt” figure had no test method or source, so it shouldn’t be treated as a fact.

​What to Try with Text​:

• ​Logo text and branding​: Short names or slogans in a mockup
• ​UI​ mockups​: Labels and buttons for a visual concept
• ​Signage and posters​: Large headline text
• ​Infographics​: Layout exploration before final typesetting
• ​Product packaging​: Early box-art concepts
• ​Social media​ graphics​: Posts with integrated text elements

​Details to Inspect​:

• Baseline alignment
• Kerning and letter spacing
• Font weight and style
• Multi-line text
• Mixed-language output

​Practical Applications​:

• Marketing teams can compare campaign directions.
• Designers can create mockups with sample content.
• Social media​ managers can explore integrated text layouts.
• Product managers can visualize interface ideas.
• Publishers can test illustrations with typography.

For a final asset, read every word at full resolution. If the spelling, legal copy, or product label must be exact, add or correct that text in a design tool.

3. Speed and Efficiency

Generation speed varies by variant, resolution, provider, queue, and account limits. The original 2–10-second ranges weren’t tied to recorded tests, so they have been removed.

​Practical Impact​:

A hosted endpoint can still make creative iteration easier: submit a prompt, review the returned image, change one variable, and compare. For a production timing estimate, record the model, image size, submit time, completion time, and queue conditions over several runs. One quick result is not a dependable service benchmark.

4. Advanced Prompt Understanding

Flux 2 can interpret detailed image instructions, but complex prompts still need output review.

​Complex Instruction Following​:

• Multiple subjects and actions
• Spatial relationships such as “to the left of”
• Composition such as “low angle shot”
• Style and mood descriptors
• Photography terms such as “macro” or “golden hour”

​Style Versatility​:

• Photorealistic portraits
• Product photography
• Landscape and nature photography
• Architectural visualization
• Illustration and concept art
• Anime-inspired work
• Abstract compositions

​Example Prompt Comparison​:

​Basic Prompt​: “A coffee cup”

​Advanced Prompt​: “A white ceramic coffee cup on a rustic wooden table, photographed from slightly above with natural morning light streaming from the left window, shallow depth of field with bokeh background, product photography style”

The second prompt gives the model a clearer subject, camera position, light source, and surface. Check the actual image rather than assuming each instruction was followed.

5. Consistency and Reproducibility

For professional workflows, consistency matters. Flux 2 gives you several ways to work toward it:

​Seed-Based Reproducibility​:

• Save the seed, prompt, model, size, and endpoint together.
• Reuse them when comparing a revision.
• Change one input at a time for a useful A/B comparison.

A seed alone does not guarantee pixel-identical output across model updates, providers, or different settings.

​Multi-Asset Campaigns​:

• Use reference images when the endpoint supports them.
• Keep product details and brand colors in a review checklist.
• Compare outputs side by side before publishing a batch.

​Production Pipeline Integration​:

This approach helps with automated generation and review. It does not replace QA for logos, labels, product geometry, or color accuracy.

API Access via WaveSpeedAI

Running Flux 2 Dev locally can require substantial hardware and setup. The original claim that the “full model demands 90GB of VRAM” as a universal minimum was too broad: local memory needs depend on the implementation and precision. Hosted API access lets you start without configuring a local GPU.

Why Choose WaveSpeedAI for Flux 2?

Unified ​API​​​ Access​:

• One API account can access multiple Flux 2 endpoints.
• The REST pattern is similar across supported models.
• Standard HTTP requests work from Python or another language.

​Published Pricing​:

• ​Flux 2 Max text-to-image​: $0.07 per generated image
• ​Flux 2 Flex text-to-image​: $0.06 per generated image
• ​Flux 2 Pro text-to-image​: $0.03 per generated image
• ​Flux 2 Dev text-to-image​: $0.012 per generated image
• ​Flux 2 Pro Edit​: $0.06 per edited image

Those are the displayed WaveSpeedAI prices checked on ​November 1, 2026​. Recheck the selected model page before placing a large order. Black Forest Labs’ direct API uses its own pricing, which can vary with output megapixels.

​Production ​Workflow​:

The API returns a task ID that you use to query the result. Record that ID. If a submit request has an unclear network outcome, check whether the task exists before submitting again; a second submission may create another billed job.

The original promises of identical first-call latency, a specific uptime SLA, and particular enterprise features are omitted because they weren’t established for these endpoints in the article’s evidence.

Code Examples

The examples below use the current WaveSpeedAI REST endpoint pattern. Install requests, set WAVESPEED_API_KEY in your environment, and run the first helper before the later snippets. These examples show the documented request and polling flow; they aren’t a published latency or output-quality test.

Python: Basic Text-to-Image Generation

import os
import time
import requests

API = "https://api.wavespeed.ai/api/v3"
HEADERS = {
    "Authorization": f"Bearer {os.environ['WAVESPEED_API_KEY']}",
    "Content-Type": "application/json",
}

def run_model(route, payload):
    response = requests.post(
        f"{API}/wavespeed-ai/{route}",
        headers=HEADERS,
        json=payload,
        timeout=60,
    )
    response.raise_for_status()
    task_id = response.json()["data"]["id"]

    for _ in range(120):
        response = requests.get(
            f"{API}/predictions/{task_id}/result",
            headers=HEADERS,
            timeout=30,
        )
        response.raise_for_status()
        result = response.json()["data"]
        status = result["status"]

        if status == "completed":
            return result["outputs"]
        if status in {"failed", "cancelled", "timeout", "deleted"}:
            raise RuntimeError(f"Task {task_id}: {status} — {result.get('error')}")
        time.sleep(2)

    raise TimeoutError(f"Task {task_id} is still running; poll this ID again.")

prompt = (
    "A professional product photo of a sleek black wireless headphone "
    "on a minimalist white surface, studio lighting with soft shadows, "
    "shallow depth of field, commercial photography style"
)

image_url = run_model("flux-2-pro/text-to-image", {"prompt": prompt})[0]
print(f"Image URL: {image_url}")

download = requests.get(image_url, timeout=60)
download.raise_for_status()
with open("headphones.png", "wb") as file:
    file.write(download.content)

The saved filename is your choice; check the returned image format if your downstream workflow depends on a specific encoding.

Python: Advanced Configuration with Seed Control

prompt = "A futuristic cityscape at sunset, cyberpunk aesthetic"
seed = 12345

first = run_model(
    "flux-2-flex/text-to-image",
    {"prompt": prompt, "seed": seed},
)
repeat = run_model(
    "flux-2-flex/text-to-image",
    {"prompt": prompt, "seed": seed},
)
variation = run_model(
    "flux-2-flex/text-to-image",
    {"prompt": prompt, "seed": seed + 1},
)

print("First:", first[0])
print("Same settings:", repeat[0])
print("Different seed:", variation[0])

Keep the model route and output settings the same when comparing these images. The original example invented a fallback seed of 42 when no seed was returned; that would not reproduce an unknown first run.

Python: Batch Generation for Campaign Assets

campaigns = [
    ("Modern smartphone on a clean desk, morning light, product photography",
     "social_product_1.png"),
    ("Happy diverse team collaborating in modern office, bright and energetic",
     "social_team_1.png"),
    ("Abstract data visualization with blue accent color, tech aesthetic",
     "social_abstract_1.png"),
    ("Cozy coffee shop interior with laptop, warm atmosphere, lifestyle shot",
     "social_lifestyle_1.png"),
]

successful = 0
for prompt, filename in campaigns:
    print(f"Generating: {filename}")
    image_url = run_model("flux-2-pro/text-to-image", {"prompt": prompt})[0]
    download = requests.get(image_url, timeout=60)
    download.raise_for_status()

    with open(filename, "wb") as file:
        file.write(download.content)
    successful += 1

print(f"Generated {successful}/{len(campaigns)} images successfully")

This sends jobs one at a time. Before turning it into a larger batch, add task-ID storage, error handling for each item, and a human review step.

Python: Integration Example

def generate_image(prompt, options=None):
    options = options or {}
    route = options.get("route", "flux-2-pro/text-to-image")
    save_path = options.get("save_path", "output.png")
    payload = {"prompt": prompt}

    if options.get("seed") is not None:
        payload["seed"] = options["seed"]

    try:
        image_url = run_model(route, payload)[0]
        download = requests.get(image_url, timeout=60)
        download.raise_for_status()

        with open(save_path, "wb") as file:
            file.write(download.content)

        print(f"Image saved to {save_path}")
        return {"success": True, "url": image_url}
    except (requests.RequestException, RuntimeError, TimeoutError) as error:
        print(f"Generation failed: {error}")
        return {"success": False, "error": str(error)}

result = generate_image(
    "A serene mountain landscape at golden hour, professional photography",
    {"route": "flux-2-max/text-to-image", "save_path": "landscape.png"},
)
print("Generation result:", result)

Python: Simple API Testing

output = run_model(
    "flux-2-pro/text-to-image",
    {
        "prompt": (
            "A sleek modern sports car on a mountain road at sunset, "
            "cinematic photography"
        )
    },
)
print(f"Generated image: {output[0]}")

Product Photo Editing: Keep One Product Consistent

Generating three similar product shots from three independent text prompts can change the label, shape, or material between images. For an existing product, start from the same source photo and edit its surroundings.

Say you have one approved headphone image. Create three outputs from that file: a white studio background, a warm desk scene, and a dark campaign background. Keep the product image as the first reference each time, and make the instruction explicit: preserve the headphone shape, logo, color, buttons, and packaging text; change only the background and lighting. Review the three outputs side by side for differences you did not request. This is a ​workflow​ example​, not a claim that I ran and scored three edits.

With the helper above, a WaveSpeedAI Pro Edit request looks like this:

source_image = "https://example.com/approved-headphones.jpg"

outputs = run_model(
    "flux-2-pro/edit",
    {
        "images": [source_image],
        "prompt": (
            "Keep the headphones, logo, buttons, and product color unchanged. "
            "Replace only the background with a clean white studio surface "
            "and soft shadows."
        ),
    },
)
print(outputs[0])

Use an image URL your API can access. For a second reference, add it to images and explain its role in the prompt. The WaveSpeedAI Pro Edit documentation currently allows up to three image URLs; Black Forest Labs’ direct editing guide describes up to eight through its own API. The request fields differ too: WaveSpeedAI uses images, while the BFL example uses input_image and additional numbered fields. Check the provider before copying a payload between them.

Comparison with Competitors

How does Flux 2 stack up against other image generators? The answer depends on the specific task and endpoint. The original article used undated leaderboard scores and unsupported cross-provider prices, so the comparisons below focus on what to test rather than declaring measured winners.

Flux 2 vs GPT Image 1.5 (OpenAI)

For text-heavy layouts, compare exact spelling, line breaks, and how much post-editing each output needs. For product work, compare material details and whether the product stays recognizable after an edit.

​Flux 2 consideration​: Its Max, Flex, Pro, and open-weight Dev routes give you different deployment and control choices.

​Decision​: Run the same brief, size, and reference assets through both services. Save the model version, cost, and usable-output rate before naming a winner for your workflow.

Flux 2 vs Midjourney v7

Midjourney can be useful for visual exploration and community-driven inspiration. Flux 2 may fit better when your workflow requires a documented API route or open weights through Dev.

​Decision​: If the deliverable is an isolated concept, compare visual results. If it is an automated asset pipeline, compare integration and revision steps as well as the images.

Flux 2 vs Seedream 4.5 (ByteDance)

Both can be evaluated for product scenes and images containing text. Don’t assume that a published sample proves one handles your packaging label or reference photo better.

​Decision​: Use the same source product, prompt, and output requirements. Check object identity, label accuracy, background changes, and the number of usable edits.

Flux 2 vs Stable Diffusion 3

Both offer ways to build local or customized workflows, but “open” has to be read at the level of the particular weights and license.

​Decision​: Compare the versions you can actually deploy, their license terms, hardware requirements, and output quality on your own images. The fact that some researchers worked on both families is not, by itself, evidence of a quality win.

Overall Competitive Position

Flux 2’s practical strength is its ​choice of variants and access paths​. Max targets detail-critical work; Pro is a production starting point; Flex emphasizes control; Dev gives developers access to weights. The best choice still depends on how often an output passes your own review.

Best Practices for Flux 2

Prompt Engineering Tips

1. Be Specific About Style and Medium

❌ Weak: "A forest"
✅ Strong: "A misty forest at dawn, professional nature photography, soft natural light filtering through trees, shallow depth of field"

2. Include Technical Photography Details

• Lighting: “golden hour,” “studio lighting,” “natural window light”
• Camera: “macro lens,” “wide angle,” “telephoto compression”
• Effects: “bokeh background,” “motion blur,” “long exposure”
• Composition: “rule of thirds,” “centered composition,” “low angle shot”

3. Specify Materials and Textures

✅ "A leather wallet on marble surface with brass accents, product photography, detailed texture, professional lighting"

4. Use Multi-Part Prompts for Complex Scenes

✅ "Foreground: A wooden desk with open laptop and coffee cup.
Middle ground: Large window showing city skyline.
Background: Sunset sky with warm colors.
Style: Corporate photography, warm color grading, shallow depth of field."

5. State Exclusions in the Prompt

The original WaveSpeedAI example sent a negative_prompt field to Flex, but that field is not listed in the endpoint parameters checked for this revision. Put the constraint in the supported prompt field instead:

output = run_model(
    "flux-2-flex/text-to-image",
    {"prompt": "A clean modern kitchen, tidy countertops, bright natural light"},
)
print(output[0])

Optimizing for Speed vs Quality

​Fast Iteration Mode (Flux 2 Flex/Dev​​**)**​:

output = run_model(
    "flux-2-dev/text-to-image",
    {"prompt": "Your creative prompt here"},
)
print(f"Generated: {output[0]}")

​**Maximum Quality Mode (Flux 2 Max/Pro)**​:

output = run_model(
    "flux-2-max/text-to-image",
    {
        "prompt": "Your creative prompt here",
        "seed": 12345,
        "size": "2048*2048",
    },
)
print(f"Generated: {output[0]}")

Confirm that the requested size is accepted by the endpoint, and compare the output at the size where it will actually be used. Changing variants is a quality experiment, not a guaranteed upgrade.

Workflow Best Practices

1. Start Broad, Refine Narrow

• Begin with Dev or Flex to explore directions.
• Test multiple prompt variations.
• Use Pro or Max for a final comparison when the project warrants it.

2. Use Seeds for Variation Control

prompt = "Your creative prompt"
base_seed = 42

base = run_model(
    "flux-2-flex/text-to-image",
    {"prompt": prompt, "seed": base_seed},
)
print(f"Base image: {base[0]}")

for i in range(1, 5):
    variation = run_model(
        "flux-2-flex/text-to-image",
        {"prompt": prompt, "seed": base_seed + i},
    )
    print(f"Variation {i}: {variation[0]}")

3. Batch Similar Assets Together

For campaigns with consistent style requirements:

prompts = [
    "Product A on white background, studio photography",
    "Product B on white background, studio photography",
    "Product C on white background, studio photography",
]

for i, prompt in enumerate(prompts):
    output = run_model(
        "flux-2-pro/text-to-image",
        {"prompt": prompt, "seed": 12345 + i},
    )
    print(f"Product {i + 1}: {output[0]}")

Use references and visual review if the products must share more than a general style. Related seeds alone do not enforce brand consistency.

4. Cost ​Optimization​​ Strategy

• ​Exploration​: Dev for initial concept testing
• ​Refinement​: Flex if its controls suit the task
• ​Production​: Pro when it produces usable final assets
• ​Hero shots​: Max when its output justifies the additional cost

Track ​cost per accepted image​, not only price per request. The original “60–70% savings” claim had no batch records or calculation, so it has been removed.

Handling Text Rendering

While Flux 2 can generate text in images, it’s not perfect. Best practices:

1. Keep Text Simple and Short

✅ Easier to check: "SALE" or "COFFEE"
❌ More demanding: "Premium Artisanal Coffee Blend"

2. Specify Font Characteristics

✅ "Bold sans-serif text reading 'OPEN' on storefront, clean modern font"

3. Generate Multiple Attempts

base_seed = 54321
prompt = "Poster with large text 'FUTURE' in bold geometric font"

for i in range(3):
    output = run_model(
        "flux-2-max/text-to-image",
        {"prompt": prompt, "seed": base_seed + i},
    )
    print(f"Text variation {i + 1}: {output[0]}")

Read the text in each result. Three attempts are an editing tactic, not a statistically supported accuracy rate.

4. Use Reference Images or Post-Processing

If you need exact product copy, use an approved image where the edit route supports it, then correct the final text in post-processing if needed.

Color Consistency for Brands

Method 1: Hex Codes in the Prompt

Black Forest Labs documents hex-code color instructions. The original color_guidance API field was not part of the WaveSpeedAI endpoint schema checked here, so keep the code in the prompt:

output = run_model(
    "flux-2-max/text-to-image",
    {"prompt": "Modern tech startup office, accent color #3CA2F6"},
)
print(f"Image: {output[0]}")

Method 2: Descriptive Color Language

✅ "Vibrant electric blue (#3CA2F6), warm coral accents, clean white background"

Method 3: Seed-Based Comparison

Once you find a generation with useful brand colors, save its prompt and seed. Compare the next result against the approved palette; use post-processing when exact color values matter.

Frequently Asked Questions

General Questions

Q: What’s the difference between Flux 2 and Flux 1?

A: Flux 2 adds a newer model family with text-to-image generation, reference-based editing, typography workflows, and output options up to 4MP on supported routes. The 32B figure refers to Dev. A precise quality comparison with Flux 1 needs a named version and dated test; the original undated LM Arena score comparison has been removed.

Q: Which Flux 2 variant should I start with?

A: It depends on your goal:

• ​Learning/experimentation​: Dev
• ​Creative control​: Flex
• ​Production ​workflow​: Pro
• ​Detail-critical asset​: Max

Start with the least costly route that can meet your acceptance criteria, then compare another variant if it cannot.

Q: Can I run Flux 2 locally?

A: You can run the open-weight Dev release locally. Hardware needs depend on precision, offloading, image size, and software. Check the official repository and model card for the setup you plan to use. Max, Flex, and Pro in this guide are hosted routes.

​Q: Is Flux 2 ​open source​**?**

A: Partially. The official inference code and the Dev weights are available, but they have different licenses. Dev’s weights are under the ​FLUX Non-Commercial License​; “open weights” does not mean unrestricted use of the model. Review the current terms before self-hosted commercial work. Max, Flex, and Pro are available through hosted services.

Technical Questions

Q: How many images can I generate per minute?

A: That depends on the endpoint, account limits, resolution, queue, and whether you submit tasks concurrently. The original “10–20 images per minute” figure was not supported by a recorded test. For planning, measure completed requests over several representative runs and check your account’s current rate limits.

Q: What image resolutions does Flux 2 support?

A: The wider family supports outputs up to 4MP on applicable routes. The accepted size values are provider and endpoint specific; WaveSpeedAI examples use a width*height string such as "1024*1024". Validate the intended size against the exact endpoint before building a batch.

Q: Does Flux 2 support inpainting or image editing?

A: Yes, through image-editing workflows. Keep generation and editing endpoints separate: an edit request supplies source image URLs as well as a prompt. For exact local repairs, inspect the route’s supported controls rather than assuming that every endpoint exposes a mask-based inpainting parameter.

Q: Can I train custom LoRAs on Flux 2?

A: Dev’s available weights make it the relevant starting point for custom training experiments. Check the training implementation, required memory, license, and dataset format before starting. The original “500–2,000 images in 2–8 hours on an A100” was not backed by a reproducible training record, so it is not presented as a baseline.

Q: How does seed control work?

A: A seed helps you compare outputs while holding other inputs steady. Save the prompt, model route, version where available, size, references, and seed together. Identical seeds should not be treated as a cross-provider or cross-version promise of identical pixels.

Commercial and Licensing

Q: Can I use Flux 2 images commercially?

A: Check the terms for the specific route and provider you use. The Dev model card distinguishes use of generated outputs from rights to use or adapt the model weights. For hosted use, review the provider’s current commercial-use policy before client delivery.

Q: Do I need to credit Flux 2 or Black Forest Labs?

A: Check the license and provider terms that apply to your workflow. Don’t infer attribution rules from the fact that a model is available by API or that its weights can be downloaded.

Q: Are there content restrictions?

A: Yes. Review the provider’s content policy and the applicable model license before submitting sensitive, third-party, or potentially restricted material.

Pricing and Billing

Q: How much does Flux 2 cost on WaveSpeedAI?

A: On ​November 1, 2026​, the displayed text-to-image prices were Dev ​**$0.012​, Pro ​$0.03​, Flex ​$0.06​, and Max $0.07 per generated image. Pro Edit was listed separately at ​$0.06 per edited image**​. Verify current prices and any output-specific conditions before purchasing credits or estimating a campaign.

Q: Is there a free tier or trial?

A: Offers can change. Check the current WaveSpeedAI account and billing pages rather than relying on a fixed promise of free credits or card-free access.

Q: How does Flux 2 pricing compare to competitors?

A: Compare the price of the ​actual output you can use​, not only a listed per-image rate. Include editing calls, resolution, retries, and manual corrections. The original competitor price ranges and “75% cheaper” claim lacked a dated like-for-like calculation.

Troubleshooting

Q: My generated images have garbled text. How do I fix this?

A: Keep text short, specify the exact wording and font style, generate a few variations, and inspect each result at full size. Add critical copy in post-processing if the model keeps changing letters.

Q: Colors don’t match my brand guidelines. What should I do?

A: Put the hex code and a plain-language color description in the prompt, compare several outputs with the approved palette, and correct the final image in post-processing if the exact value matters. A seed helps with comparison; it does not certify color accuracy.

Q: Images are too dark or bright. How do I control exposure?

A: Use lighting instructions in the prompt:

✅ Brighter: "bright lighting, well-lit, high-key lighting"
✅ Darker: "moody lighting, dramatic shadows, low-key lighting"
✅ Balanced: "natural lighting, balanced exposure, professional photography"

You can also specify the time of day and light source.

Q: ​API​​ requests are ​timing​​ out. What’s wrong?

A: Check the API key, request body, image URLs, network connection, and returned task ID. If the result ​query fails temporarily, retry that query. If the submission outcome is unclear, look for the existing task before submitting again. A timed-out client request does not prove the generation stopped.

Conclusion

Flux 2 gives creative teams several ways to approach image generation and editing, from open-weight Dev experiments to hosted production routes.

​Why Flux 2 Matters​:

​For Designers and Creatives​: Explore concepts with Dev or Flex, then compare Pro or Max for assets that need closer review. Typography and editing broaden the kinds of mockups you can make, provided you check the final details.

​For Developers​: Dev provides open weights and official inference tooling. Hosted REST endpoints provide another route when local hardware or maintenance is not a good fit.

​For Businesses​: Variant choice can help match spend to the importance of an asset. Use approved product references, check terms, and review outputs before publishing a campaign.

​For Researchers​: The Dev release supports experiments with a documented model and available weights, subject to its license.

​Key Takeaways​:

1. ​Choose by task​: Max for detail-critical work, Flex for control, Pro for production, Dev for open-weight development.
2. ​Check the actual endpoint​: Reference limits, request fields, and output settings can differ between providers.
3. ​Review typography and ​product identity​: These details need an explicit QA pass.
4. ​Keep prices dated​: The figures above are a November 1, 2026 snapshot, not a permanent quote.
5. ​Measure your own workflow​: Use accepted outputs, total cost, and recorded completion times rather than an undated ranking.

​Getting Started​:

1. Choose a variant based on the asset you’re making.
2. Read its current endpoint parameters and pricing.
3. Generate one image using the code example above.
4. If you’re editing an approved product photo, use the edit route and keep the source image as your reference.
5. Save the prompt, seed, model route, and result for your next comparison.

What will you create with Flux 2?

---

Previous posts:

• Comfy Cloud review
• Comfy Cloud alternatives
• Holo4 API vs local deployment
• Kling 4.0 reference-to-video guide
• Kling 4.0 keyframe guide