Flux 2 JSON Prompting: How to Use Structured Prompts for Better Results

I stumbled onto JSON prompting by accident. A client needed 200 product images with identical lighting but different colored backgrounds. Traditional prompting was a nightmare. Every background color shift pulled the lighting slightly different directions.

Then I discovered Flux 2's JSON format. Problem solved in an afternoon.

Most creators skip JSON prompting because it looks intimidating. Curly braces. Nested objects. Syntax errors. But once you understand the structure, you get control that text prompts literally cannot provide. Explicit weights. Regional conditioning. Precise parameter control.

Black Forest Labs designed this for production workflows where "close enough" doesn't cut it. If you're generating one-off images for fun, stick with text prompts. But if you need consistency across batches, or programmatic generation through APIs, or surgical control over competing prompt elements? JSON prompting changes everything.

Quick Answer: Flux 2 JSON prompting is a structured format that replaces traditional text prompts with JSON objects containing parameters like reference image weights, regional prompts, negative conditions, and compositional constraints. JSON prompts provide programmatic control for batch generation, multi-reference weighting, and parameter precision that natural language prompts cannot achieve, making them essential for commercial workflows requiring consistency across large image sets.

TL;DR - JSON Prompting Essentials

• What it does: JSON prompting structures your Flux 2 prompts as machine-readable JSON objects instead of plain text
• Best for: Batch generation, multi-reference workflows, programmatic image creation, commercial applications
• Precision gain: Control reference weights to 0.01 precision, define regional prompts with exact coordinates
• Compatibility: Works with Flux 2 Dev and Flux 2 Pro only, not Flux 2 Schnell or Flux 1
• Learning curve: Moderate if you understand JSON, steep if you don't know JSON syntax
• Use cases: E-commerce product variations, character consistency, systematic testing, API integration
• Format structure: JSON object with prompt, negative_prompt, reference_images, regions, and parameters fields
• Tool support: Native in official Flux 2 API, supported in ComfyUI with custom nodes

Understanding JSON prompting separates casual Flux 2 users from professionals building production workflows. This guide covers everything from basic JSON structure to advanced multi-reference weighting and programmatic generation strategies.

What Exactly Is JSON Prompting in Flux 2?

JSON prompting replaces traditional natural language prompts with structured JSON objects that define every aspect of your generation request. Instead of writing "portrait of a woman with red hair, natural lighting, professional photography," you create a JSON structure that separates style parameters, subject description, lighting conditions, and quality settings into distinct, weighted fields.

Traditional text prompts force everything into one linear string. The model interprets your prompt holistically, balancing competing elements based on training rather than your explicit intent. JSON prompting breaks this limitation by giving you direct control over how different prompt components influence the final image.

A basic JSON prompt structure looks like this:

{
  "prompt": "portrait of a woman with red hair",
  "style": "professional photography",
  "lighting": "natural window light from left",
  "quality": "8k, high detail, sharp focus",
  "negative_prompt": "blurry, low quality, artificial"
}

Each field receives separate processing attention, preventing the common issue where quality tags like "8k" compete with subject descriptions for model attention. When working with complex ComfyUI workflows, understanding how different prompting methods interact becomes crucial. Our ComfyUI beginner mistakes guide covers common pitfalls when transitioning to advanced prompting techniques.

Flux 2's JSON implementation extends beyond simple field separation. The system supports reference image arrays with individual weights, regional prompting with coordinate-based divisions, negative conditioning at parameter level, and compositional constraints that define spatial relationships mathematically.

This structured approach enables workflows impossible with text prompts. Generate 100 product images with identical lighting but systematically varied backgrounds. Create character consistency across scenes by locking character description while programmatically varying environment. Test prompt variations methodically by changing one JSON field while holding others constant.

The precision matters most for commercial applications. When a client needs product shots matching exact brand guidelines, JSON prompting lets you encode those guidelines as reusable JSON templates. No more guessing which text prompt produces on-brand results. You define parameters once, then generate unlimited variations.

Why Use JSON Prompts Instead of Traditional Text Prompts?

Text prompts work fine for casual exploration and creative experimentation. JSON prompting becomes essential when you need consistency, precision, or automation at scale.

Parameter Separation and Weight Control

Text prompts merge everything into one stream. The prompt "professional product photography, studio lighting, white background, high quality, sharp focus, 8k" processes all elements together with implicit weights based on word position and frequency.

JSON prompting separates concerns with explicit weights:

{
  "subject": {"content": "premium leather wallet", "weight": 1.5},
  "style": {"content": "professional product photography", "weight": 1.2},
  "lighting": {"content": "studio lighting, soft shadows", "weight": 1.0},
  "background": {"content": "pure white background", "weight": 0.8},
  "quality": {"content": "8k, sharp focus, high detail", "weight": 0.6}
}

The weight values tell Flux 2 exactly how much attention each component deserves. Subject gets maximum attention at 1.5, while quality descriptors receive lower 0.6 weight since they're modifiers rather than primary content.

This separation prevents quality tags from overwhelming subject description, a common problem where "8k ultra HD photorealistic masterpiece" text prompts produce technically sharp images of the wrong subject.

Multi-Reference Image Weighting

Flux 2's multi-reference support allows up to 10 reference images simultaneously. Text prompts cannot specify which reference images matter more. JSON prompting assigns precise weights:

{
  "prompt": "woman in business attire, professional setting",
  "reference_images": [
    {"image": "face_reference.jpg", "weight": 1.5, "type": "face"},
    {"image": "pose_reference.jpg", "weight": 1.2, "type": "pose"},
    {"image": "clothing_reference.jpg", "weight": 1.0, "type": "style"},
    {"image": "background_reference.jpg", "weight": 0.4, "type": "environment"}
  ]
}

Face reference gets highest weight to maintain identity. Pose reference receives strong but secondary influence. Background reference provides environmental context without overpowering the subject. This weighted approach produces better character consistency than equal-weight references. For more on maintaining character consistency across generations, see our comprehensive character consistency guide.

Regional Prompting with Coordinate Precision

Text prompts cannot specify spatial relationships precisely. "Man on left, woman on right" relies on model interpretation. JSON regional prompting defines exact boundaries:

{
  "base_prompt": "professional photography, studio lighting",
  "regions": [
    {
      "coordinates": {"x": 0, "y": 0, "width": 0.5, "height": 1.0},
      "prompt": "man in navy suit, confident expression",
      "weight": 1.2
    },
    {
      "coordinates": {"x": 0.5, "y": 0, "width": 0.5, "height": 1.0},
      "prompt": "woman in red dress, warm smile",
      "weight": 1.2
    }
  ]
}

The coordinates field defines regions as normalized 0-1 values. Left region spans x=0 to 0.5 (left half), right region spans x=0.5 to 1.0 (right half). Both receive equal 1.2 weight for balanced importance. If you're using SDXL or SD1.5 models, our Regional Prompter ComfyUI guide covers similar multi-region control techniques.

This precision eliminates attribute bleeding where character A gets character B's features, a persistent problem with text-based multi-subject prompts.

Programmatic Generation and Automation

JSON's structured format enables automated workflows. Generate systematic variations by programmatically modifying JSON fields:

base_template = {
  "prompt": "modern chair in {environment}",
  "style": "product photography",
  "lighting": "{lighting_type}",
  "quality": "8k, professional"
}

environments = ["living room", "office", "outdoor patio", "bedroom"]
lighting_types = ["natural light", "studio lighting", "golden hour", "soft diffused"]

for env in environments:
  for light in lighting_types:
    prompt = base_template.copy()
    prompt["prompt"] = prompt["prompt"].format(environment=env)
    prompt["lighting"] = prompt["lighting"].format(lighting_type=light)
    # Generate with modified JSON prompt

This programmatic approach generates 16 systematic variations in minutes. Text prompts require manual rewriting for each combination, introducing inconsistency and typos.

Consistency Across Large Batches

Commercial applications often need hundreds of images following exact specifications. JSON templates guarantee consistency:

{
  "prompt": "{product_name}",
  "style": "e-commerce product photography",
  "lighting": "soft studio lighting, no harsh shadows",
  "background": "pure white, seamless",
  "camera": "medium format, 85mm lens equivalent",
  "quality": "sharp focus, high detail, commercial quality",
  "negative_prompt": "blur, distortion, shadows, reflections"
}

Replace the product_name field, generate, repeat. Every output matches brand guidelines because the JSON template encodes those guidelines directly. Text prompts drift over time as humans naturally vary wording, breaking consistency.

API Integration and Workflow Automation

When integrating Flux 2 into applications via API, JSON prompts are natural data structures. Your application builds JSON objects programmatically based on user inputs, database queries, or business logic.

Text prompts require string manipulation and template filling, introducing bugs from improper escaping, quote handling, and delimiter conflicts. JSON handles these concerns through standard libraries in every programming language.

Understanding Flux 2 JSON Prompt Structure and Syntax

Flux 2's JSON prompt schema defines specific fields, data types, and nesting structures. Understanding the schema prevents errors and unlocks advanced features.

Core JSON Structure

Every valid Flux 2 JSON prompt starts with a root object containing these primary fields:

{
  "prompt": "string - primary subject description",
  "negative_prompt": "string - what to avoid",
  "style": "string - visual style and aesthetic",
  "reference_images": [],
  "regions": [],
  "parameters": {}
}

All fields are optional except prompt. Minimal valid JSON prompt:

{
  "prompt": "portrait of a woman"
}

This generates exactly like the text prompt "portrait of a woman" with no additional benefits. JSON prompting's power comes from using advanced fields.

Prompt Field Detailed Specification

The prompt field accepts strings with standard Flux 2 prompt syntax including attention weights:

{
  "prompt": "(woman with red hair:1.3), professional photography, (natural lighting:1.1)"
}

Attention weights in parentheses work identically to text prompts. However, JSON structure allows cleaner organization:

{
  "prompt": "woman with red hair, professional photography",
  "emphasis": {
    "subject": 1.3,
    "lighting": 1.1
  }
}

Some Flux 2 implementations support the emphasis field for weight control separate from prompt text. Check your specific implementation documentation.

Negative Prompt Implementation

The negative_prompt field defines what to exclude:

{
  "prompt": "portrait of a woman",
  "negative_prompt": "blurry, low quality, distorted, artificial, oversaturated"
}

Negative prompts work identically in JSON and text formats. JSON's advantage is separating negative concerns into categories:

{
  "prompt": "portrait of a woman",
  "negative_prompt": {
    "technical": "blurry, low quality, distorted, noise",
    "aesthetic": "oversaturated, artificial, fake",
    "content": "multiple people, crowd, background clutter"
  }
}

Whether your implementation supports nested negative prompts depends on the specific Flux 2 API or ComfyUI node you use. The official Black Forest Labs API supports flat string negative prompts universally.

Reference Images Array Structure

The reference_images field takes an array of objects, each describing one reference image:

{
  "prompt": "woman in professional setting",
  "reference_images": [
    {
      "path": "references/face_01.jpg",
      "weight": 1.5,
      "influence_type": "identity",
      "region": null
    },
    {
      "path": "references/outfit_02.jpg",
      "weight": 1.0,
      "influence_type": "style",
      "region": {"x": 0.3, "y": 0.4, "width": 0.4, "height": 0.6}
    }
  ]
}

Each reference image object contains:

• path: File path or URL to reference image
• weight: Influence strength from 0.0 to 2.0, default 1.0
• influence_type: What aspect the reference affects (identity, style, pose, composition)
• region: Optional coordinate object limiting reference influence to specific image area

The influence_type field helps Flux 2 understand your intent. "identity" references focus on facial features and character appearance. "style" references affect aesthetic and artistic treatment. "pose" references guide body positioning and posture.

Regions Array for Regional Prompting

The regions field enables multi-prompt compositions with precise spatial control:

{
  "base_prompt": "professional photography, studio lighting",
  "regions": [
    {
      "coordinates": {
        "x": 0.0,
        "y": 0.0,
        "width": 0.5,
        "height": 1.0
      },
      "prompt": "man in business suit, confident pose",
      "negative_prompt": "casual clothing, relaxed",
      "weight": 1.2,
      "feather": 0.1
    },
    {
      "coordinates": {
        "x": 0.5,
        "y": 0.0,
        "width": 0.5,
        "height": 1.0
      },
      "prompt": "woman in professional attire, warm expression",
      "negative_prompt": "formal, stern",
      "weight": 1.2,
      "feather": 0.1
    }
  ]
}

Region coordinates use normalized 0-1 scale where 0,0 is top-left corner and 1,1 is bottom-right. The feather parameter (0.0-1.0) controls boundary softness between regions, preventing hard seams.

Parameters Object for Generation Control

The parameters field contains generation settings typically passed separately in API calls:

{
  "prompt": "portrait of a woman",
  "parameters": {
    "width": 1024,
    "height": 1024,
    "steps": 30,
    "cfg_scale": 7.5,
    "sampler": "euler_a",
    "seed": 42,
    "batch_size": 4
  }
}

Including generation parameters in JSON prompts creates fully self-contained generation definitions. Save the entire JSON file and reproduce identical results later by using the same seed and parameters.

JSON Syntax Validation

Invalid JSON syntax causes immediate errors. Common mistakes:

Wrong: Missing comma between fields

{
  "prompt": "test"
  "style": "photo"
}

Correct: Comma after each field except last

{
  "prompt": "test",
  "style": "photo"
}

Wrong: Single quotes instead of double quotes

{
  'prompt': 'test'
}

Correct: Double quotes for all strings

{
  "prompt": "test"
}

Wrong: Trailing comma after last field

{
  "prompt": "test",
}

Correct: No comma after final field

{
  "prompt": "test"
}

Use JSON validators like jsonlint.com to verify syntax before submitting to Flux 2. Most programming languages have built-in JSON validation libraries.

Available Parameters and Options in Flux 2 JSON Prompts

Flux 2's JSON schema supports numerous parameters controlling generation behavior. Understanding which parameters exist and their valid ranges prevents trial-and-error guessing.

Core Prompt Parameters

prompt (string, required): Primary positive prompt describing desired image content. Supports Flux 2's full prompt syntax including attention weights, parentheses for grouping, and comma-separated concepts.

Valid example:

"prompt": "(cyberpunk cityscape:1.3), neon lights, rain-slicked streets, (dark moody atmosphere:1.2)"

negative_prompt (string, optional): Content to avoid or suppress. Works like positive prompts but inverted.

Valid example:

"negative_prompt": "blurry, low quality, distorted, oversaturated, watermark, text"

style (string, optional): Overall aesthetic and visual treatment. Some implementations use this for style presets or LoRA triggers.

Valid example:

"style": "professional photography, medium format, natural lighting"

Reference Image Parameters

reference_images (array, optional): Collection of reference images with individual control.

Each array element object supports:

path (string, required): File path, URL, or base64-encoded image data

weight (float, 0.0-2.0, default 1.0): Influence strength. 0.0 disables reference, 2.0 maximum influence

type (string, optional): Reference purpose hint. Suggested values include "identity", "style", "pose", "composition", "color", "lighting"

region (object, optional): Limit reference influence to specific area

Example demonstrating all reference parameters:

"reference_images": [
  {
    "path": "https://example.com/reference.jpg",
    "weight": 1.5,
    "type": "identity",
    "region": {
      "x": 0.25,
      "y": 0.2,
      "width": 0.5,
      "height": 0.6
    }
  }
]

Regional Prompting Parameters

regions (array, optional): Define multiple prompt regions with individual control.

Each region object supports:

coordinates (object, required): Region position and size

• x (float, 0.0-1.0): Left edge position, 0.0 is left, 1.0 is right
• y (float, 0.0-1.0): Top edge position, 0.0 is top, 1.0 is bottom
• width (float, 0.0-1.0): Region width as fraction of image
• height (float, 0.0-1.0): Region height as fraction of image

prompt (string, required): Prompt content for this region

negative_prompt (string, optional): Region-specific negative prompt

weight (float, 0.0-2.0, default 1.0): Region importance relative to other regions

feather (float, 0.0-1.0, default 0.0): Boundary softness, 0.0 is hard edge, 1.0 is maximum blur

Example showing region parameters:

"regions": [
  {
    "coordinates": {"x": 0.0, "y": 0.0, "width": 1.0, "height": 0.3},
    "prompt": "dramatic sky with storm clouds",
    "weight": 0.9,
    "feather": 0.15
  },
  {
    "coordinates": {"x": 0.0, "y": 0.3, "width": 1.0, "height": 0.7},
    "prompt": "mountain landscape with forest",
    "weight": 1.1,
    "feather": 0.15
  }
]

Generation Control Parameters

The parameters object controls technical generation settings:

width (integer, multiple of 8): Output width in pixels. Flux 2 supports up to 2048 typically

height (integer, multiple of 8): Output height in pixels. Must be multiple of 8 for VAE compatibility

steps (integer, 1-50): Sampling steps. Flux 2 Dev typically uses 20-30, Schnell uses 4-8

cfg_scale (float, 1.0-20.0): Classifier-free guidance scale. Higher values follow prompt more strictly. Flux 2 typically uses 7-9

sampler (string): Sampling algorithm. Common options include "euler", "euler_a", "dpmpp_2m", "dpmpp_sde". Flux 2 works best with "euler" or "euler_a"

scheduler (string): Noise schedule. Options include "normal", "karras", "exponential", "sgm_uniform"

seed (integer): Random seed for reproducibility. Use same seed with same prompt for identical results

batch_size (integer, 1-10): Number of images to generate simultaneously

Example parameters object:

"parameters": {
  "width": 1024,
  "height": 1024,
  "steps": 28,
  "cfg_scale": 7.5,
  "sampler": "euler_a",
  "scheduler": "normal",
  "seed": 123456,
  "batch_size": 1
}

Advanced Control Parameters

Some Flux 2 implementations support advanced parameters:

attention_mask (array): Define attention weights per region for fine control

composition_constraints (object): Enforce compositional rules like symmetry or golden ratio

style_interpolation (array): Blend multiple style references with weights

These advanced parameters vary by implementation. The official Black Forest Labs API supports core parameters universally, while ComfyUI custom nodes may extend functionality.

How Do You Write Effective JSON Prompts for Different Use Cases?

Theory matters less than practical application. Here are proven JSON prompt patterns for common use cases, ready to adapt for your projects.

Portrait Photography with Reference Face

Generate professional portraits maintaining specific identity:

{
  "prompt": "professional headshot, business attire, confident expression",
  "negative_prompt": "casual, candid, blurry, low quality",
  "style": "corporate photography, studio lighting, neutral background",
  "reference_images": [
    {
      "path": "client_face.jpg",
      "weight": 1.6,
      "type": "identity"
    }
  ],
  "parameters": {
    "width": 1024,
    "height": 1024,
    "steps": 30,
    "cfg_scale": 8.0,
    "sampler": "euler_a"
  }
}

High reference weight (1.6) ensures strong facial consistency. Explicit negative prompt prevents casual aesthetic. Style field separates environmental description from subject.

E-Commerce Product Photography Variations

Generate multiple background variations while maintaining product consistency:

{
  "prompt": "premium leather handbag, centered composition, product photography",
  "negative_prompt": "blur, distortion, shadows, reflections, multiple products",
  "style": "commercial product photography, professional lighting",
  "reference_images": [
    {
      "path": "product_master.jpg",
      "weight": 1.8,
      "type": "identity"
    },
    {
      "path": "background_lifestyle.jpg",
      "weight": 0.6,
      "type": "environment"
    }
  ],
  "parameters": {
    "width": 1024,
    "height": 1024,
    "steps": 25,
    "cfg_scale": 7.5
  }
}

Very high product reference weight (1.8) locks product appearance. Low background weight (0.6) provides environmental context without overwhelming product. Generate variations by swapping background reference while keeping product reference constant. For more product photography techniques, see our best prompts for product photography guide.

Multi-Character Scene with Regional Control

Generate two distinct characters without attribute bleeding:

{
  "base_prompt": "professional photography, natural lighting, outdoor park setting",
  "negative_prompt": "blur, low quality, distorted faces",
  "regions": [
    {
      "coordinates": {"x": 0.0, "y": 0.2, "width": 0.45, "height": 0.8},
      "prompt": "man in casual blue shirt and jeans, friendly smile, short brown hair",
      "weight": 1.3,
      "feather": 0.12
    },
    {
      "coordinates": {"x": 0.55, "y": 0.2, "width": 0.45, "height": 0.8},
      "prompt": "woman in summer dress, warm expression, long blonde hair",
      "weight": 1.3,
      "feather": 0.12
    },
    {
      "coordinates": {"x": 0.0, "y": 0.0, "width": 1.0, "height": 0.2},
      "prompt": "blue sky with scattered clouds",
      "weight": 0.8,
      "feather": 0.2
    }
  ],
  "parameters": {
    "width": 1536,
    "height": 1024,
    "steps": 30,
    "cfg_scale": 8.0
  }
}

Separate regions prevent character attribute mixing. Feathering (0.12) creates natural boundaries without hard seams. Background region has lower weight to avoid dominating characters.

Systematic Style Testing

Test multiple artistic styles on same subject for comparison:

{
  "prompt": "ancient temple in forest clearing",
  "reference_images": [
    {
      "path": "temple_composition.jpg",
      "weight": 1.2,
      "type": "composition"
    }
  ],
  "style": "STYLE_VARIABLE",
  "parameters": {
    "width": 1024,
    "height": 768,
    "steps": 25,
    "cfg_scale": 7.5,
    "seed": 12345
  }
}

Replace STYLE_VARIABLE programmatically with "oil painting", "watercolor", "pencil sketch", "photorealistic", "anime", etc. Fixed seed and composition reference ensure only style changes between generations, enabling direct comparison.

Character Consistency Across Multiple Scenes

Maintain character appearance while varying environment:

{
  "prompt": "ENVIRONMENT_VARIABLE, full body shot, professional photography",
  "negative_prompt": "multiple people, crowd, blur",
  "reference_images": [
    {
      "path": "character_face_01.jpg",
      "weight": 1.5,
      "type": "identity",
      "region": {"x": 0.35, "y": 0.1, "width": 0.3, "height": 0.35}
    },
    {
      "path": "character_fullbody_01.jpg",
      "weight": 1.2,
      "type": "identity"
    },
    {
      "path": "character_outfit_01.jpg",
      "weight": 1.0,
      "type": "style"
    }
  ],
  "parameters": {
    "width": 768,
    "height": 1024,
    "steps": 28,
    "cfg_scale": 8.0
  }
}

Multiple reference images with different weights provide multi-aspect consistency. Face reference limited to upper region focuses facial influence where it matters. Replace ENVIRONMENT_VARIABLE with "modern office interior", "city street at night", "mountain hiking trail", etc., while character appearance remains consistent.

Architectural Visualization with Depth Layers

Create architectural renders with appropriate detail distribution by depth:

{
  "base_prompt": "architectural rendering, professional visualization, clear day",
  "negative_prompt": "blur, distortion, unrealistic perspective",
  "regions": [
    {
      "coordinates": {"x": 0.0, "y": 0.7, "width": 1.0, "height": 0.3},
      "prompt": "modern glass building facade, architectural details visible, sharp focus, high detail textures",
      "weight": 1.4,
      "feather": 0.1
    },
    {
      "coordinates": {"x": 0.0, "y": 0.3, "width": 1.0, "height": 0.4},
      "prompt": "building entrance, pedestrians, urban environment, moderate detail",
      "weight": 1.1,
      "feather": 0.15
    },
    {
      "coordinates": {"x": 0.0, "y": 0.0, "width": 1.0, "height": 0.3},
      "prompt": "city skyline background, atmospheric perspective, soft focus",
      "weight": 0.8,
      "feather": 0.2
    }
  ],
  "parameters": {
    "width": 1024,
    "height": 1536,
    "steps": 32,
    "cfg_scale": 7.5
  }
}

Weight and detail decrease with distance, creating realistic atmospheric depth. Increasing feather values for distant regions creates natural depth-of-field effect.

Batch Generation Template for Automation

Create reusable template for programmatic generation:

{
  "prompt": "{SUBJECT} in {ENVIRONMENT}, {STYLE_DESCRIPTOR}",
  "negative_prompt": "blur, low quality, distorted, {SPECIFIC_EXCLUSIONS}",
  "style": "{VISUAL_STYLE}",
  "parameters": {
    "width": 1024,
    "height": 1024,
    "steps": 25,
    "cfg_scale": 7.5,
    "seed": "{SEED_VALUE}",
    "batch_size": 1
  }
}

Replace template variables programmatically to generate systematic variations. This approach enables A/B testing, dataset creation, and automated content generation for applications.

Combining JSON Prompts with Text Prompts

Some Flux 2 implementations support hybrid approaches combining JSON structure with text prompt fallbacks. Understanding when and how to mix approaches optimizes flexibility.

JSON Wrapper for Text Prompts

Simplest hybrid wraps text prompts in minimal JSON structure:

{
  "prompt": "cyberpunk street scene, neon lights, rainy night, cinematic composition"
}

This provides JSON format benefits (programmatic handling, validation, extensibility) while keeping prompt simplicity. Useful when integrating text-based workflows into JSON-expecting APIs.

Gradual JSON Adoption Strategy

Start with text prompts, progressively add JSON features as complexity requires:

Stage 1 - Basic JSON wrapper:

{
  "prompt": "portrait of a woman, professional photography"
}

Stage 2 - Add negative prompts:

{
  "prompt": "portrait of a woman, professional photography",
  "negative_prompt": "blur, low quality"
}

Stage 3 - Introduce reference images:

{
  "prompt": "portrait of a woman, professional photography",
  "negative_prompt": "blur, low quality",
  "reference_images": [
    {"path": "face_ref.jpg", "weight": 1.4}
  ]
}

Stage 4 - Add regional control:

{
  "base_prompt": "professional photography",
  "negative_prompt": "blur, low quality",
  "reference_images": [
    {"path": "face_ref.jpg", "weight": 1.4}
  ],
  "regions": [
    {
      "coordinates": {"x": 0.2, "y": 0.1, "width": 0.6, "height": 0.8},
      "prompt": "portrait of a woman, business attire"
    }
  ]
}

This gradual approach prevents overwhelming users transitioning from text prompts while enabling feature adoption as needs grow.

Text Prompts with JSON Parameters

Some workflows keep creative prompts as text while using JSON for technical parameters:

{
  "prompt": "A weathered sailor standing on the deck of a ship during a storm, dramatic lighting breaking through dark clouds, sea spray and wind, intense expression, photorealistic",
  "negative_prompt": "cartoon, anime, low quality, blur",
  "parameters": {
    "width": 1536,
    "height": 1024,
    "steps": 30,
    "cfg_scale": 8.0,
    "sampler": "euler_a",
    "seed": 42
  }
}

This keeps prompt writing natural while gaining JSON benefits for parameter management and reproducibility.

Regional Prompts with Text Fallback

Define regions in JSON but keep prompt content as natural text:

{
  "base_prompt": "Professional photography, studio lighting, high quality",
  "regions": [
    {
      "coordinates": {"x": 0.0, "y": 0.0, "width": 0.5, "height": 1.0},
      "prompt": "A confident businesswoman in her 30s wearing a tailored navy suit, standing with professional posture, warm but professional expression"
    },
    {
      "coordinates": {"x": 0.5, "y": 0.0, "width": 0.5, "height": 1.0},
      "prompt": "A modern office interior with floor-to-ceiling windows, city skyline visible, natural daylight, minimal contemporary furniture"
    }
  ]
}

Regions provide spatial structure while text prompts maintain creative flexibility. This hybrid works well for complex compositions requiring regional control but benefiting from natural language expressiveness.

Migrating Existing Text Prompts to JSON

Convert proven text prompts to JSON format to gain structure benefits:

Original text prompt:

portrait of an elderly man with white beard, weathered face, kind eyes, wearing wool sweater, natural window lighting from left, shallow depth of field, professional photography, 8k, high detail

Converted to structured JSON:

{
  "prompt": "portrait of an elderly man with white beard, weathered face, kind eyes",
  "style": "professional photography, shallow depth of field",
  "lighting": "natural window lighting from left",
  "clothing": "wearing wool sweater",
  "quality": "8k, high detail",
  "parameters": {
    "width": 1024,
    "height": 1024,
    "steps": 28,
    "cfg_scale": 7.5
  }
}

The JSON version separates concerns, making it easier to modify lighting without touching subject description, or adjust quality settings independently.

When to Use Pure Text vs Pure JSON vs Hybrid

Use pure text prompts when:

• Quick creative exploration and iteration
• Single-image generation without consistency requirements
• Simple prompts without multi-region or multi-reference needs
• Working with tools that don't support JSON input

Use pure JSON prompts when:

• Building production workflows requiring consistency
• Programmatic generation or API integration
• Complex multi-reference or regional compositions
• Systematic testing and A/B comparison
• Need to version control and track prompt variations

Use hybrid approaches when:

• Transitioning from text to JSON workflows
• Teams with mixed technical skill levels
• Maintaining creative flexibility while gaining structure benefits
• Legacy prompt libraries need JSON wrapper for new systems

The choice depends on your specific workflow, technical requirements, and team capabilities rather than one approach being universally superior.

Best Practices and Pro Tips for JSON Prompting

Adopting JSON prompting effectively requires understanding not just syntax but strategic approaches that maximize its benefits while avoiding common pitfalls.

Start with Templates and Build Libraries

Don't write JSON prompts from scratch each time. Create template libraries for common use cases:

// templates/portrait-professional.json
{
  "prompt": "{SUBJECT_DESCRIPTION}",
  "style": "professional portrait photography, studio lighting",
  "negative_prompt": "casual, candid, blur, low quality",
  "parameters": {
    "width": 1024,
    "height": 1024,
    "steps": 28,
    "cfg_scale": 7.5
  }
}

// templates/product-ecommerce.json
{
  "prompt": "{PRODUCT_NAME}, centered composition",
  "style": "e-commerce product photography, white background",
  "negative_prompt": "shadows, reflections, blur, multiple products",
  "parameters": {
    "width": 1024,
    "height": 1024,
    "steps": 25,
    "cfg_scale": 7.0
  }
}

Build your template library over time, saving successful prompts for reuse and adaptation. Version control these templates to track improvements.

Use Consistent Naming Conventions

Adopt systematic naming for template variables and file organization:

templates/
  portraits/
    portrait-professional-studio.json
    portrait-natural-outdoor.json
    portrait-dramatic-lowkey.json
  products/
    product-ecommerce-white-bg.json
    product-lifestyle-environment.json
    product-detail-closeup.json
  architectural/
    arch-exterior-daylight.json
    arch-interior-residential.json

Consistent naming makes templates discoverable and indicates use case at a glance. For larger workflows, our batch processing guide covers systematic approaches to high-volume generation.

Weight Values Strategy

Reference and region weights follow patterns for reliable results:

Reference image weights:

• 0.3-0.5: Subtle influence, inspiration only
• 0.8-1.0: Moderate influence, balanced with prompt
• 1.2-1.5: Strong influence, reference dominates
• 1.6-2.0: Maximum influence, minimal deviation from reference

Regional prompt weights:

• 0.6-0.8: Background elements, supporting context
• 0.9-1.1: Standard elements, balanced importance
• 1.2-1.5: Primary subjects, focal points
• 1.6+: Dominant elements (use sparingly, can overpower composition)

Start conservative (1.0) and adjust incrementally (±0.2) based on results rather than making dramatic weight changes.

Feathering for Natural Transitions

Region feathering prevents hard boundaries:

{
  "regions": [
    {
      "coordinates": {"x": 0.0, "y": 0.0, "width": 1.0, "height": 0.4},
      "prompt": "dramatic sky with sunset colors",
      "feather": 0.2
    },
    {
      "coordinates": {"x": 0.0, "y": 0.4, "width": 1.0, "height": 0.6},
      "prompt": "mountain landscape",
      "feather": 0.2
    }
  ]
}

Feather values 0.15-0.25 create natural transitions for most scenes. Lower values (0.05-0.1) for hard boundaries like geometric compositions. Higher values (0.3-0.4) for artistic blends and dreamlike effects.

Validation Before Generation

Always validate JSON syntax before submitting to Flux 2. Invalid JSON causes immediate errors wasting generation time and credits.

Python validation:

import json

def validate_flux_prompt(prompt_json):
    try:
        parsed = json.loads(prompt_json)
        # Check required fields
        if "prompt" not in parsed:
            return False, "Missing required 'prompt' field"
        return True, "Valid"
    except json.JSONDecodeError as e:
        return False, f"Invalid JSON: {e}"

JavaScript validation:

function validateFluxPrompt(promptJson) {
  try {
    const parsed = JSON.parse(promptJson);
    if (!parsed.prompt) {
      return {valid: false, error: "Missing required 'prompt' field"};
    }
    return {valid: true};
  } catch (e) {
    return {valid: false, error: `Invalid JSON: ${e.message}`};
  }
}

Version Control Your Prompts

Track JSON prompts in git for reproducibility and iteration history:

prompts/
  campaign-spring-2025/
    v1-initial.json
    v2-refined-lighting.json
    v3-final-approved.json
  product-line-alpha/
    variant-a.json
    variant-b.json

Git commits document what changed and why, critical for teams collaborating on prompt development or tracking A/B test variations.

Commenting JSON for Team Workflows

Standard JSON doesn't support comments, but use field naming for documentation:

{
  "prompt": "professional headshot",
  "_comment_style": "Changed to softer lighting per client feedback 2025-01-15",
  "style": "natural lighting, soft shadows",
  "_comment_reference_weight": "Increased to 1.5 to match brand guidelines",
  "reference_images": [
    {"path": "brand_face.jpg", "weight": 1.5}
  ]
}

Fields starting with underscore get ignored by parsers but provide inline documentation. Alternatively, use JSON5 format which supports actual comments (if your implementation allows).

Progressive Complexity Approach

Don't jump immediately to complex multi-region multi-reference JSON prompts. Build complexity progressively:

1. Start with simple prompt + negative_prompt JSON
2. Add reference images once comfortable with structure
3. Introduce regional prompting for multi-element scenes
4. Combine references + regions only when necessary
5. Add advanced parameters for fine-tuning

Each layer adds complexity. Master one level before adding the next to avoid overwhelming debugging when things don't work.

Testing Variations Systematically

Use JSON structure to test prompt variations methodically:

base_prompt = {
  "prompt": "mountain landscape",
  "style": "STYLE_VAR",
  "parameters": {"width": 1024, "height": 768, "seed": 42}
}

styles = ["oil painting", "watercolor", "photography", "digital art"]

for style in styles:
  test_prompt = base_prompt.copy()
  test_prompt["style"] = style
  # Generate with test_prompt
  # Save result as f"test_{style}.png"

Systematic testing with controlled variables reveals which parameters produce desired effects, building knowledge faster than random experimentation.

Error Handling in Programmatic Workflows

When generating programmatically, implement robust error handling:

import json
import requests

def generate_flux_image(prompt_dict):
    try:
        # Validate JSON structure
        prompt_json = json.dumps(prompt_dict)

        # API call
        response = requests.post(
            "https://api.bfl.ml/flux2/generate",
            json=prompt_dict,
            timeout=60
        )

        if response.status_code == 200:
            return response.json()
        else:
            return {"error": f"API error: {response.status_code}"}

    except json.JSONDecodeError as e:
        return {"error": f"Invalid JSON: {e}"}
    except requests.Timeout:
        return {"error": "Request timeout"}
    except Exception as e:
        return {"error": f"Unexpected error: {e}"}

Production workflows need error handling for validation failures, API timeouts, network issues, and unexpected responses.

Common Errors and Troubleshooting JSON Prompts

JSON prompting introduces specific failure modes distinct from text prompt issues. Recognizing error patterns accelerates debugging.

Syntax Errors

Problem: JSON fails to parse

Common causes:

• Missing or extra commas
• Single quotes instead of double quotes
• Unescaped special characters in strings
• Unclosed brackets or braces

Fix: Use JSON validator (jsonlint.com) or code editor with JSON validation. Most editors highlight syntax errors immediately.

Example error:

{
  "prompt": "test with "quotes" inside"
}

Fixed:

{
  "prompt": "test with \"quotes\" inside"
}

Weight Values Outside Valid Range

Problem: Generation fails or produces unexpected results

Cause: Reference or region weights outside 0.0-2.0 range

Fix: Clamp all weight values to valid range:

{
  "reference_images": [
    {"path": "ref.jpg", "weight": 1.5}  // Valid
  ]
}

Avoid:

{
  "reference_images": [
    {"path": "ref.jpg", "weight": 3.0}  // Invalid, too high
  ]
}

Coordinate Values Outside 0.0-1.0

Problem: Regional prompts fail or cover unexpected areas

Cause: Region coordinates use pixel values instead of normalized 0-1 range

Wrong:

{
  "coordinates": {"x": 100, "y": 50, "width": 500, "height": 700}
}

Correct:

{
  "coordinates": {"x": 0.1, "y": 0.05, "width": 0.5, "height": 0.7}
}

Missing Required Fields

Problem: API returns validation error

Cause: Omitted required fields in JSON structure

Fix: Ensure all required fields present. Minimum valid prompt:

{
  "prompt": "your subject description"
}

For regions, coordinates and prompt are required:

{
  "regions": [
    {
      "coordinates": {"x": 0, "y": 0, "width": 1, "height": 1},
      "prompt": "required content"
    }
  ]
}

Reference Image Path Errors

Problem: Generation fails with "cannot load reference image" error

Cause: Invalid file paths, missing files, unsupported formats

Fix: Verify reference images exist at specified paths, use absolute paths or valid URLs, and confirm images are in supported formats (JPG, PNG, WebP).

{
  "reference_images": [
    {"path": "/absolute/path/to/image.jpg", "weight": 1.2}
  ]
}

For API usage, use URLs instead of local paths:

{
  "reference_images": [
    {"path": "https://example.com/reference.jpg", "weight": 1.2}
  ]
}

Overlapping Regions with Conflicting Prompts

Problem: Region boundaries show artifacts or unexpected content

Cause: Regions overlap with conflicting prompts and similar weights

Fix: Use weight hierarchy for overlapping regions:

{
  "regions": [
    {
      "coordinates": {"x": 0, "y": 0, "width": 1, "height": 1},
      "prompt": "background landscape",
      "weight": 0.8
    },
    {
      "coordinates": {"x": 0.3, "y": 0.2, "width": 0.4, "height": 0.7},
      "prompt": "character portrait",
      "weight": 1.4
    }
  ]
}

Higher weight region dominates in overlap areas.

Prompt Too Long

Problem: Generation fails with "prompt too long" error

Cause: Prompt text exceeds maximum token limit (typically 256 tokens for Flux 2)

Fix: Shorten prompts by removing redundant words, use JSON structure to separate concerns instead of cramming into single prompt field, and split complex descriptions across base_prompt and regional prompts.

Excessive:

{
  "prompt": "highly detailed ultra realistic 8k photographic portrait of a professional businesswoman in her late 20s with shoulder length brown hair and hazel eyes wearing a navy blue tailored business suit standing in a modern office with floor to ceiling windows..."
}

Better:

{
  "prompt": "professional businesswoman, late 20s, brown hair, hazel eyes, navy suit",
  "style": "photorealistic portrait, 8k, highly detailed",
  "environment": "modern office, floor to ceiling windows",
  "lighting": "natural window light, professional"
}

Parameter Type Mismatches

Problem: API returns type error

Cause: Wrong data type for parameter (string instead of number, etc.)

Wrong:

{
  "parameters": {
    "width": "1024",  // String instead of number
    "steps": "30"     // String instead of number
  }
}

Correct:

{
  "parameters": {
    "width": 1024,   // Number
    "steps": 30      // Number
  }
}

Unsupported Features in Different Flux 2 Variants

Problem: JSON features work in Flux 2 Dev but fail in Flux 2 Schnell

Cause: Different Flux 2 variants support different feature sets

Fix: Check variant-specific documentation. Flux 2 Schnell doesn't support some advanced features like multi-reference weighting or complex regional prompting that Flux 2 Dev supports.

Generation Results Don't Match Expectations

Problem: Image generates but doesn't follow JSON prompt structure

Cause: Implementation doesn't support full JSON schema or interprets fields differently

Fix: Verify your Flux 2 implementation (API, ComfyUI node, etc.) supports the JSON features you're using. Test with minimal JSON prompt first, then add features incrementally to identify which features work. Consult implementation-specific documentation for supported fields.

What Are the Practical Applications for JSON Prompting?

JSON prompting excels in specific scenarios where its structured approach provides measurable advantages over text prompts.

E-Commerce Product Catalog Generation

Generate hundreds of product images with consistent styling and systematic variations:

{
  "prompt": "{product_name}, centered composition, product photography",
  "style": "professional e-commerce photography, white background",
  "lighting": "soft studio lighting, no harsh shadows",
  "negative_prompt": "blur, shadows, reflections, multiple products",
  "reference_images": [
    {"path": "{product_image}", "weight": 1.8, "type": "identity"}
  ],
  "parameters": {
    "width": 1024,
    "height": 1024,
    "steps": 25,
    "cfg_scale": 7.0
  }
}

Automate generation across entire product catalogs by programmatically replacing product_name and product_image variables. Consistent styling ensures brand coherence across thousands of images.

Character Consistency for Content Creation

Maintain character appearance across comic panels, storyboards, or illustrated content:

{
  "prompt": "{scene_description}",
  "reference_images": [
    {"path": "character_face_master.jpg", "weight": 1.6, "type": "identity"},
    {"path": "character_outfit_master.jpg", "weight": 1.2, "type": "style"}
  ],
  "negative_prompt": "different person, inconsistent appearance",
  "parameters": {
    "width": 1024,
    "height": 768,
    "steps": 28,
    "cfg_scale": 8.0
  }
}

Change scene_description for each panel while character references ensure consistent appearance. This workflow scales to hundreds of panels with minimal manual effort.

A/B Testing for Marketing Materials

Test multiple creative variations systematically:

base_prompt = {
  "prompt": "HEADLINE_TEXT, marketing banner, professional design",
  "style": "STYLE_VAR",
  "reference_images": [
    {"path": "brand_logo.png", "weight": 1.0, "type": "identity"}
  ],
  "parameters": {"width": 1920, "height": 1080}
}

headlines = ["Spring Sale 50% Off", "Limited Time Offer", "New Collection Available"]
styles = ["modern minimalist", "bold vibrant", "elegant sophisticated"]

for headline in headlines:
  for style in styles:
    variant = base_prompt.copy()
    variant["prompt"] = variant["prompt"].replace("HEADLINE_TEXT", headline)
    variant["style"] = variant["style"].replace("STYLE_VAR", style)
    # Generate variant

This creates 9 systematic variations for A/B testing. JSON structure ensures controlled variation of specific elements while holding others constant.

Synthetic Training Data Generation

Create labeled training datasets for computer vision models:

{
  "prompt": "{object_class} in {environment}, {angle} view",
  "style": "photorealistic, diverse lighting conditions",
  "parameters": {
    "width": 512,
    "height": 512,
    "seed": "{sequential_seed}"
  }
}

Generate thousands of synthetic training images with known labels by iterating through object classes, environments, and angles. Sequential seeds ensure diversity while JSON tracking provides ground truth labels.

Real Estate Visualization Variations

Generate multiple interior design options for property listings:

{
  "prompt": "modern living room interior",
  "reference_images": [
    {"path": "room_layout.jpg", "weight": 1.4, "type": "composition"}
  ],
  "style": "{design_style}",
  "parameters": {
    "width": 1536,
    "height": 1024
  }
}

Keep room layout constant via composition reference while varying design_style through "scandinavian minimalist", "industrial modern", "traditional classic", etc. Clients see multiple design options from same space.

API Integration for User-Facing Applications

Build applications where users provide inputs that programmatically create JSON prompts:

function createPromptFromUserInput(userInputs) {
  return {
    prompt: `${userInputs.subject} in ${userInputs.setting}`,
    style: userInputs.selectedStyle,
    reference_images: userInputs.uploadedImages.map(img => ({
      path: img.url,
      weight: img.importance / 10
    })),
    parameters: {
      width: userInputs.resolution.width,
      height: userInputs.resolution.height
    }
  };
}

User interface inputs convert cleanly to JSON structure for API submission. This pattern works for custom image generators, design tools, and creative applications.

Systematic Prompt Engineering Research

Research optimal prompt patterns through controlled experimentation:

experiments = {
  "lighting_test": {
    "base": {"prompt": "portrait of a woman", "parameters": {"seed": 100}},
    "variables": {
      "lighting": ["natural light", "studio lighting", "golden hour", "dramatic side lighting"]
    }
  },
  "style_test": {
    "base": {"prompt": "mountain landscape", "parameters": {"seed": 200}},
    "variables": {
      "style": ["oil painting", "watercolor", "photography", "digital art"]
    }
  }
}

for test_name, test_config in experiments.items():
  for var_name, var_values in test_config["variables"].items():
    for value in var_values:
      prompt = test_config["base"].copy()
      prompt[var_name] = value
      # Generate and log results

Controlled testing reveals which prompt patterns produce desired effects, building institutional knowledge about effective prompting strategies.

Frequently Asked Questions About Flux 2 JSON Prompting

Does JSON prompting work with Flux 1 or only Flux 2?

JSON prompting is a Flux 2-specific feature. Flux 1 does not support structured JSON prompts and requires traditional text-based prompting. If you're using Flux 1, stick with optimized text prompts rather than attempting JSON format.

Can I use JSON prompts in ComfyUI?

Yes, but requires custom nodes that support Flux 2 JSON prompt parsing. The standard Flux 2 ComfyUI nodes may not support full JSON schema. Check custom node documentation for JSON support. Some implementations require JSON-to-text conversion nodes that parse JSON and feed structured data to appropriate Flux 2 conditioning nodes.

What is the maximum number of reference images in JSON prompts?

Flux 2 officially supports up to 10 reference images per generation. Exceeding this limit may cause errors or ignore additional references. For most use cases, 2-4 carefully weighted references produce better results than 10 equal-weight references.

Do JSON prompts use more credits or cost more than text prompts?

No. JSON prompts and text prompts cost the same per generation. The format doesn't affect pricing. However, JSON prompts may lead to fewer failed generations and less iteration, potentially reducing overall costs through better first-attempt success rates.

Can I convert existing text prompts to JSON automatically?

Partially. Basic conversion is straightforward by wrapping text in JSON structure. However, optimal JSON prompts require restructuring prompts to leverage JSON-specific features like weight control and regional separation. Automatic conversion gives you valid JSON but not necessarily better results than the original text prompt.

How do I debug JSON prompts that don't produce expected results?

Start by validating JSON syntax with a validator. Then simplify the prompt by removing advanced features (references, regions) and testing with minimal JSON. Add features back incrementally to identify which element causes unexpected behavior. Check implementation documentation for supported fields and value ranges.

What JSON features work across all Flux 2 implementations?

Core fields like prompt, negative_prompt, and basic parameters (width, height, steps, cfg_scale) work universally. Advanced features like multi-region prompting, reference image arrays, and complex parameter objects depend on specific implementation. Always test with your target platform to confirm feature support.

Can JSON prompts include multiple languages?

Yes. The prompt field supports any language that Flux 2's text encoder understands. Flux 2 uses multilingual text encoders that handle prompts in various languages. However, mixing languages within a single prompt may produce unpredictable results. For best results, stick to one language per generation.

Do I need programming knowledge to use JSON prompts?

Basic JSON understanding is sufficient. You need to know JSON syntax rules including proper use of quotes, commas, brackets, and braces. Programming knowledge helps for automated batch generation but isn't required for manual JSON prompt creation. Many creators use JSON templates without programming backgrounds.

How do seed values work with JSON prompts?

Identical to text prompts. Specifying a seed value in the parameters object ensures reproducible results. Same seed with same JSON prompt produces identical images. This is crucial for systematic testing and client revisions where you need to regenerate with minor modifications.

Final Thoughts

JSON prompting transforms Flux 2 from an impressive image generator into a programmable creative system. The structured format enables precision, consistency, and automation impossible with natural language prompts. For casual exploration and one-off creative images, text prompts remain simpler and faster. For production workflows, commercial applications, and systematic content generation, JSON prompting provides control that justifies the additional complexity.

The learning curve is moderate. Understanding basic JSON syntax takes hours. Mastering effective JSON prompt patterns for different use cases takes experimentation and iteration. Start with simple JSON wrappers around existing text prompts, then progressively adopt advanced features as your projects require more control. Build template libraries capturing successful patterns to accelerate future work.

JSON prompting matters most for scenarios requiring consistency across large image sets, multi-reference character or product consistency, programmatic generation integrated with applications, or systematic testing and optimization of prompt parameters. If your workflow involves any of these use cases, investing time in JSON prompting skills pays immediate dividends in output quality and iteration efficiency.

The practical examples and templates in this guide provide starting points for common scenarios. Adapt them to your specific needs, track what works through version control, and build institutional knowledge about effective JSON prompting patterns for your domain. Whether you're generating product catalogs for e-commerce, creating consistent character art for content production, building AI-powered creative tools, or researching optimal prompting strategies, JSON prompting provides the structure and precision required for professional results.

For creators who want Flux 2's powerful capabilities without managing local infrastructure or learning complex JSON syntax, Apatero.com provides browser-based access to Flux 2 with pre-built JSON templates for common use cases. You get the benefits of structured prompting through simple form interfaces that generate optimized JSON prompts behind the scenes, making advanced Flux 2 features accessible without technical barriers.

The future of AI image generation moves toward greater control and precision. JSON prompting represents that direction, giving creators explicit control over aspects previously left to model interpretation. Mastering JSON prompting positions you at the forefront of production-grade AI image generation, where consistency, reproducibility, and systematic optimization separate professional workflows from experimental exploration.

Sources:

• FLUX.2 Day-0 Support in ComfyUI
• black-forest-labs/FLUX.2-dev - Hugging Face
• GitHub - black-forest-labs/flux2: Official inference repo for FLUX.2 models