FLUX.2 API: image generation

Use flux-2-pro for most FLUX.2 work. Generation and editing share one JSON endpoint billed per call, and each result URL expires 10 minutes after generation, so download it right away.

Item	Details
`flux-2-pro`	$0.03 per call; the recommended default
`flux-2-flex`	$0.06 per call; Black Forest Labs describes it as specialized for text rendering and small details
`flux-2-max`	$0.07 per call; Black Forest Labs’ model with the strongest prompt following
Pricing	Public pricing as of September 24, 2026; see the model and pricing catalog
Endpoint	`POST https://api.laozhang.ai/v1/images/generations` with a JSON body
Request	A `model`, a `prompt`, and an output size
Result	An image URL in `data[0].url`, valid for 10 minutes
Editing	Add reference images on the same endpoint; see FLUX.2 image editing

All three models use the same request format.

Before you start

Create an API key

FLUX.2 models are billed per call. In Token management, create a key (or edit an existing one) and set Billing mode (计费模式) to Usage first (按量优先, recommended) or Per-call (按次计费). A Usage first key can call both per-call and usage-based models; a Per-call key calls only per-call models.Keep the key in a server-side environment variable.

In Token management, create a token with Billing mode set to Per-call (按次计费), then select Create.

Set up your environment

Export the key and install requests, which the Python examples use:

export LAOZHANG_API_KEY="YOUR_LAOZHANG_API_KEY"
python3 -m pip install requests

Generate an image

This request creates a 1792×1024 landscape image and writes the response to flux-generation.json:

curl --fail-with-body "https://api.laozhang.ai/v1/images/generations" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "flux-2-pro",
    "prompt": "A ruby red retro robot riding a yellow skateboard in front of a turquoise glass greenhouse, clean product illustration style",
    "size": "1792x1024"
  }' \
  -o flux-generation.json

Save the result

The response contains data[0].url, and that URL expires 10 minutes after the image is generated, so download it right away. FLUX returns only URLs, never b64_json. Save this script as save_images.py; it downloads every image in a response (it also decodes b64_json, which some other image models return):

save_images.py

import base64
import json
import sys
import urllib.request
from pathlib import Path

response_file, stem = sys.argv[1], sys.argv[2]
response = json.loads(Path(response_file).read_text())
if not response.get("data"):
    sys.exit(f"No image in {response_file}: {response}")

for number, item in enumerate(response["data"], start=1):
    if item.get("b64_json"):
        # Drop an optional data:image/...;base64, prefix and restore missing padding.
        value = item["b64_json"].split(",", 1)[-1]
        image = base64.b64decode(value + "=" * (-len(value) % 4))
    else:
        with urllib.request.urlopen(item["url"], timeout=120) as download:
            image = download.read()
    if image.startswith(b"\x89PNG"):
        extension = "png"
    elif image[:4] == b"RIFF" and image[8:12] == b"WEBP":
        extension = "webp"
    else:
        extension = "jpg"
    path = Path(f"{stem}-{number}.{extension}")
    path.write_bytes(image)
    print(f"Saved {path}")

python3 save_images.py flux-generation.json flux-robot

The script prints Saved flux-robot-1.jpg. FLUX.2 returns JPEG unless you set output_format to png.

Generate with Python

import os
from pathlib import Path

import requests

response = requests.post(
    "https://api.laozhang.ai/v1/images/generations",
    headers={"Authorization": f"Bearer {os.environ['LAOZHANG_API_KEY']}"},
    json={
        "model": "flux-2-pro",
        "prompt": "A cinematic product photo of a transparent smart speaker on a marble table",
        "size": "1024x1024",
    },
    timeout=240,
)
response.raise_for_status()
image_url = response.json()["data"][0]["url"]

# The result URL expires after 10 minutes, so download it immediately.
download = requests.get(image_url, timeout=120)
download.raise_for_status()
image = download.content

extension = "png" if image.startswith(b"\x89PNG") else "jpg"
output = Path(f"flux-speaker.{extension}")
output.write_bytes(image)
print(f"Saved {output}")

Output size

Set the output size with an OpenAI-style size string or with width and height in pixels. Use one form, not both.

`size`	Output	Typical use
`1024x1024`	1024×1024	Square images, avatars, product shots
`1792x1024`	1792×1024	Landscape covers, banners, hero images
`1024x1792`	1024×1792	Portrait posters, mobile covers, story images

width and height must be multiples of 16 and at least 64 pixels, with no more than about 4 megapixels in total (for example, 2048×2048). Edits take the same size fields.

Edit an image

Add input_image to the same JSON request to edit an image instead of starting from text alone. This minimal edit keeps the subject of a public image and replaces its background:

curl --fail-with-body "https://api.laozhang.ai/v1/images/generations" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "flux-2-pro",
    "prompt": "Keep the same main subject. Change the background to a clean pale blue studio backdrop and preserve the original lighting.",
    "input_image": "https://example.com/source.png",
    "size": "1792x1024",
    "output_format": "png"
  }' \
  -o flux-edit.json

python3 save_images.py flux-edit.json flux-edit

Multiple references work only through these JSON fields on this endpoint. For local files, up to eight references, a Python helper, and edit prompts, see FLUX.2 image editing.

Parameters

Parameter	Type	Required	Description
`model`	string	Yes	`flux-2-pro`, `flux-2-flex`, or `flux-2-max`
`prompt`	string	Yes	What to generate
`size`	string	No	Output size such as `1792x1024`; default `1024x1024`
`width`, `height`	integer	No	Output size in pixels: multiples of 16, at least 64, up to about 4 MP in total; use instead of `size`
`n`	integer	No	Number of images; only `1` is supported
`output_format`	string	No	`jpeg` (default) or `png`
`seed`	integer	No	Fixed seed for repeatable results
`input_image` … `input_image_8`	string	No	Reference images, as public URLs or data URLs; adding them turns the request into an edit

Legacy compatibility: FLUX Kontext

flux-kontext-pro ($0.035 per call) and flux-kontext-max ($0.07 per call) remain available for existing integrations. They use the same endpoint, with these differences:

They take an aspect_ratio field instead of size. With the OpenAI Python SDK, pass it through extra_body.
Any ratio from 3:7 to 7:3 works, and the output stays at about one megapixel.

Common ratios and their approximate output:

`aspect_ratio`	Approximate output
`1:1`	1024×1024
`3:2` / `2:3`	1248×832 / 832×1248
`16:9` / `9:16`	1408×792 / 792×1408
`21:9`	1680×720
`7:3` / `3:7`	1544×662 / 662×1544

For new generation or editing work, use FLUX.2.

Frequently asked questions

Do I need to poll for results like the BFL API?

No. The BFL API returns a task ID and a polling_url that you poll until the status is Ready. LaoZhang API waits for the image within the same request and returns it in data[0].url. Give the client a generous timeout instead; the Python example uses 240 seconds. If the request passes through a reverse proxy or a serverless function, raise its timeout or execution limit as well, or the connection closes before the image is ready.

Why does the image URL stop working?

Result URLs expire 10 minutes after generation, the same lifetime BFL gives its own result links. Download each image on your server as soon as its request returns, store it in your own storage, and hand that address to your database or front end. In batch jobs, download each result as its request finishes instead of waiting for the whole batch, and keep concurrency low enough that downloads keep pace. An expired URL can’t be refreshed. Send the request again, which is billed as a new call.

How do I get repeatable results?

Send the same seed with the same model, prompt, and size. This helps when you iterate on one design.

How do I get accurate text and brand colors?

For text-heavy images such as posters, infographics, and UI mockups, try flux-2-flex first; BFL positions it for text rendering and small details. Use flux-2-max when you need the highest quality and the strongest prompt following. To match brand colors, put hex codes in the prompt, for example the mug is #FF5A1F. For complex scenes, you can also write the subject, background, lighting, and style as a JSON string and send it as the prompt.

Am I charged for failed requests?

No. FLUX.2 is billed per call: a request that returns an image is charged once, while a non-200 response, such as a parameter error or a moderation block, isn’t charged. A client timeout isn’t the same as a failure. The server may have finished the image and charged for it, so check call logs before you resend. Call logs are the final record of what you were charged.

Can I use the OpenAI SDK?

Yes, with client.images.generate():

Set base_url to https://api.laozhang.ai/v1.
Pass model, prompt, and size as usual.
Put FLUX-specific fields such as width, height, and seed in extra_body.

The image URL is in response.data[0].url; download it right away. For edits, also use client.images.generate() and put input_image in extra_body; client.images.edit() accepts only one image. See the FLUX.2 image editing FAQ.

FLUX.2 image editing: edit one image or combine up to eight references
Choose an image generation API: compare FLUX.2 with other image models
Images API reference: shared request and response format
Model and pricing catalog: current FLUX prices and groups
Call logs: check the model and charge for each request
Models and pricing in the console: prices available to your account
Black Forest Labs: FLUX.2 overview: what each FLUX.2 variant is built for, hex color control, and structured prompts
Black Forest Labs: API integration guidelines: BFL’s asynchronous polling flow and 10-minute result URLs

Get started

Image Generation & Editing APIs

Video Generation APIs

Text APIs

Multimodal & Audio APIs

FLUX.2 API: image generation

Before you start

Generate an image

Save the result

Generate with Python

Output size

Edit an image

Parameters

Legacy compatibility: FLUX Kontext

Frequently asked questions

Do I need to poll for results like the BFL API?

Why does the image URL stop working?

How do I get repeatable results?

How do I get accurate text and brand colors?

Am I charged for failed requests?

Can I use the OpenAI SDK?

​Before you start

​Generate an image

​Save the result

​Generate with Python

​Output size

​Edit an image

​Parameters

​Legacy compatibility: FLUX Kontext

​Frequently asked questions

​Do I need to poll for results like the BFL API?

​Why does the image URL stop working?

​How do I get repeatable results?

​How do I get accurate text and brand colors?

​Am I charged for failed requests?

​Can I use the OpenAI SDK?

​Related documentation

Before you start

Generate an image

Save the result

Generate with Python

Output size

Edit an image

Parameters

Legacy compatibility: FLUX Kontext

Frequently asked questions

Do I need to poll for results like the BFL API?

Why does the image URL stop working?

How do I get repeatable results?

How do I get accurate text and brand colors?

Am I charged for failed requests?

Can I use the OpenAI SDK?

Related documentation