GPT Image 2.6 Flare and Sunburst

openai/gpt-image-2.6-flare and openai/gpt-image-2.6-sunburst are OpenAI's image models. Both generate images, animated GIFs, and SVGs from text and edit existing images. Generation runs on /v1/images/generations, editing on /v1/images/edits.

Which one to choose

Flare: work where response time matters most, fast iteration and drafts, product visuals and posters. For a quick draft, send quality: "low".
Sunburst: work where detail, layout, and precise edits matter; keeping characters, products, and brand elements consistent across edits. Choose medium quality or above for this.

The two models take the same fields and prices, so changing the model id is enough. When you compare them, repeat each request a few times: the same request does not return the same image every time.

Prices

Prices are per 1 million tokens and are OpenAI's list prices. No margin is added to model prices; the platform margin applies only when credits are topped up.

Model	Text input	Image input	Image output
`openai/gpt-image-2.6-flare`	5.00	8.00	30.00
`openai/gpt-image-2.6-sunburst`	5.00	8.00	30.00

An image's output cost varies with quality and size. Approximate amounts per image according to OpenAI's calculator, excluding input:

Quality	1024x1024	1536x1024	3840x2160
`low`	$0.025	$0.020	$0.047
`medium`	$0.043	$0.034	$0.086
`high`	$0.053	$0.041	$0.100
`xhigh`	$0.094	$0.074	$0.178
`max`	$0.211	$0.165	$0.400

The exact amount is calculated from the usage field in the response; for SVG, svg_usage is added. complexity does not change the price on its own.

The highest likely amount is set aside from your balance before the request starts and is then settled at the real amount. size: "auto", quality: "auto", and edit, GIF, and SVG requests with no size are set aside at the highest possible amount, so if you run on a low balance, write the size and quality explicitly.

Text to image

curl "$LLMTR_BASE_URL/v1/images/generations" \
  -H "Authorization: Bearer llmtr-your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-image-2.6-flare",
    "prompt": "A ceramic coffee cup on a wooden table, natural light, product photo",
    "size": "1024x1024",
    "quality": "low",
    "complexity": "low",
    "output_format": "webp"
  }'

The image comes back as base64 in data[0].b64_json, and its format is in data[0].mime_type. Complex prompts can take up to two minutes, so set your client's timeout accordingly.

Parameters

Field	Values	Notes
`size`	`auto` or `WIDTHxHEIGHT`	Edges are multiples of 16, at most 3840; ratio up to 3:1; 655,360 to 8,294,400 pixels in total. Above `2560x1440` is experimental at OpenAI. Defaults to `1024x1024`; for edits, GIF, and SVG the model picks the size.
`quality`	`low`, `medium`, `high`, `xhigh`, `max`, `auto`	Defaults to `medium`.
`complexity`	`low`, `medium`, `high`	How much the model plans before rendering. Defaults to `high`.
`output_format`	`png`, `jpeg`, `webp`, `gif`, `svg`	Defaults to `png`. `gif` and `svg` are for generation only.
`output_compression`	`0`-`100`	With `jpeg` and `webp` only.
`background`	`opaque`, `auto`, `transparent`	`transparent` works with `png`, `webp`, and `svg`, and not with `jpeg` or `gif`.
`moderation`	`auto`, `low`	Uses the provider default when omitted.
`n`	`1`-`6`	Number of images in one request. Must be `1` for SVG.
`frame_count`	`2`-`16`	GIF only. Defaults to 9.
`frame_duration_ms`	`20`-`2000`	GIF only, duration per frame, rounded to 10 ms. Defaults to 200.

stream: true and partial_images are rejected on these models. A prompt is at most 32,000 characters.

Complexity

quality sets how much detail goes into rendering, while complexity sets how much the model plans the scene. For focused edits, such as changing a background, start with low and check the surrounding details. For dense text, complex layouts, and relationships between objects, start with the default high; higher values can take longer and introduce changes you did not ask for. When you compare levels, keep quality fixed.

Animated GIF

curl "$LLMTR_BASE_URL/v1/images/generations" \
  -H "Authorization: Bearer llmtr-your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-image-2.6-flare",
    "prompt": "A small grey ball bouncing on a plain floor, seamless loop",
    "output_format": "gif",
    "frame_count": 9,
    "frame_duration_ms": 200,
    "size": "512x512",
    "quality": "low"
  }'

Decode data[0].b64_json from base64 and save it as .gif. Here size is the size of each frame, and its edges must be multiples of 16. The frame count, frame size, and n together must fit the total pixel limit; if they do not, the request is refused, so lower frame_count, the frame size, or n. If you send no size, a frame size that fits the limit is chosen. transparent and output_compression cannot be used with GIF.

SVG

curl "$LLMTR_BASE_URL/v1/images/generations" \
  -H "Authorization: Bearer llmtr-your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-image-2.6-sunburst",
    "prompt": "A flat, two-colour coffee cup icon",
    "output_format": "svg",
    "quality": "low"
  }'

Decode data[0].b64_json from base64 and save the UTF-8 XML with a .svg extension. According to OpenAI, the document is static: it contains no scripts, external resources, or embedded raster images. It is still model output, so show it with <img> on your page rather than inlining it into HTML. n can only be 1, and output_compression cannot be used. The document can come back with a transparent background even if you send no background.

An SVG is produced in two steps and billed as two items. The model you chose draws a reference image; quality sets that image, and it is billed at the prices above. openai/gpt-6-luna then writes the document, and that item is billed at that model's prices. In the response, usage shows the reference image and svg_usage shows the model that wrote the document:

{
  "usage": { "input_tokens": 100, "output_tokens": 1000, "total_tokens": 1100 },
  "svg_usage": {
    "model": "openai/gpt-6-luna",
    "input_tokens": 2000,
    "output_tokens": 3000,
    "reasoning_tokens": 2000,
    "total_tokens": 5000
  }
}

The numbers only show the shape of the response and vary by request. reasoning_tokens are included in output_tokens. The model that writes the document cannot be changed, and the svg field is rejected.

Editing images

/v1/images/edits takes a JSON body. Send up to 16 images in the images array, or one image in the image field. Each item can be an https:// address, a base64 data URL, or an { "image_url": "..." } object. PNG, JPEG, and WebP are accepted. The request body is limited to 24 MB in total; use an https:// address for large images.

import base64
import os

import requests

with open("product.png", "rb") as f:
    image = "data:image/png;base64," + base64.b64encode(f.read()).decode()

response = requests.post(
    "https://llmtr.com/v1/images/edits",
    headers={"Authorization": f"Bearer {os.environ['LLMTR_API_KEY']}"},
    json={
        "model": "openai/gpt-image-2.6-flare",
        "prompt": "Replace the background with a plain light beige studio wall, leave the product alone",
        "images": [{"image_url": image}],
        "size": "1536x1024",
        "quality": "low",
        "complexity": "low",
    },
    timeout=300,
)
response.raise_for_status()
with open("result.png", "wb") as f:
    f.write(base64.b64decode(response.json()["data"][0]["b64_json"]))

The OpenAI SDK's images.edit method sends a multipart form, which this endpoint does not accept. Send JSON as above. A file_id from /v1/files cannot be used with these models.

Edits are billed per token too: the images you send count at the image input price, and the generated image at the image output price. gif and svg output cannot be used for edits.

Showing where with markup

To mark what should change, prepare a PNG with transparent pixels, the same width and height as the image, draw a circle or a sketch on it, and send it in the markup field. Do not merge this layer into the image. The mark applies to the first image, and any other images count as references. In the prompt, say what should change, what should stay, and that the mark should be removed from the result.

{
  "model": "openai/gpt-image-2.6-flare",
  "prompt": "Recolor the shirt inside the circle to white, leave the rest of the photo alone, remove the circle from the result",
  "images": [{ "image_url": "data:image/png;base64,..." }],
  "markup": { "image_url": "data:image/png;base64,..." },
  "quality": "low",
  "complexity": "low"
}

There is no separate fee for markup. markup and mask cannot be used in the same request.

Mask

The mask field takes an image in the form { "image_url": "..." }. According to OpenAI's guide, a mask must have the same size and format as the first image and include an alpha channel. The model uses the mask as guidance and may not follow its exact shape, so check the result.

Errors

Status	Meaning	What to do
`400 invalid_request`	The size, frame count, or field combination is invalid	Fix the field in the message; this request is not billed
`400 invalid_request`, `400 unsupported_input`	An unsupported image type or a `file_id`	Send PNG, JPEG, or WebP, and use `image_url`
`400 unsupported_output`	GIF or SVG was requested on the edit endpoint	Request these outputs on `/v1/images/generations`
`400 unsupported_operation`	`stream: true` or `partial_images` was sent	Remove these fields
`400 content_filter`	The request was blocked by the provider's content policy	Change the prompt or the images, and do not repeat the same request
`402 insufficient_credits`	The balance does not cover this request	Top up, write the size and quality explicitly, or choose a lower quality
`503 model_unavailable`	The model cannot serve right now	Try again later

Other requests the provider rejects return a 4xx; check and correct your fields.

OpenAI's price table lists a cached rate, but on LLMTR no cache discount applies on these models, and every request counts at the full input price.