gpt-image-2.6-flare

GPT Image 2.6 Flare

GPT Image 2.6 Flare is OpenAI's image model for fast iteration. It turns a text prompt into an image, and edits your own photos from an instruction:

• change one object;
• remove a detail;
• cut out a product on a transparent background;
• combine several references into one picture.

OpenAI says Flare can return an image in as little as six seconds at low quality. It sits second on the Artificial Analysis text-to-image arena, one place behind its sibling, Sunburst.

openai/gpt-image-2.6-flare

At a glance

Why GPT Image 2.6 Flare

• Fast. Built for interactive work: drafts, variations and quick edits. OpenAI reports Images 2.6 generates 50% faster than the previous generation.
• Near the top of the arena. #2 on the Artificial Analysis text-to-image leaderboard at the time of writing, behind only its sibling, Sunburst.
• Readable text in images. Posters, labels, slides, diagrams and UI mockups, with the wording you write.
• Edit only what you ask. Describe the change, list what must stay the same, and the rest of the photo is kept.
• Point at the change. With markup, you circle the object on a transparent layer and say what to do with it.
• Transparent cut-outs. background: "transparent" with PNG or WebP gives product images ready for a store or an ad.
• Up to 16 reference images. Combine a face, an outfit, a product and a style in one edit.
• One request away from Sunburst. Draft on Flare, then render the final with openai/gpt-image-2.6-sunburst: only the model changes.

What it makes

Photorealism. Source: OpenAI image prompting guide.

Diagrams with readable labels. Source: OpenAI image prompting guide.

An ad with the tagline written in the prompt. Source: OpenAI image prompting guide.

A mobile app mockup. Source: OpenAI image prompting guide.

Image options

Every option is optional. An option you leave out takes its default.

size: "auto" and quality: "auto" are accepted: they use the defaults above, and the response says so in _devup.warnings.

Choosing quality and complexity

• Quality is about detail. Start at medium. Use high for small text, dense diagrams and print. Use low for quick drafts.
• Complexity is about planning. high gives the model room to build the composition from a short prompt. For a targeted edit, start at low: it changes one detail with fewer unwanted changes elsewhere.
• Complexity does not change the price. Quality, size and the number of images do.

Quick start

cURL

curl -X POST 'https://api.devupai.com/v1/images/generations' \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-image-2.6-flare",
    "prompt": "A poster for a spring market in Algiers. Headline in large serif letters: \"Souk El Rabie\". Below it, smaller: \"Every Friday, 9 to 13\". Fresh oranges, mint and bread on a blue wooden stall, soft morning light.",
    "size": "1024x1536",
    "quality": "high"
  }'

Python

import base64
import os
import requests

response = requests.post(
    "https://api.devupai.com/v1/images/generations",
    headers={
        "Authorization": f"Bearer {os.environ['DEVUP_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={
        "model": "openai/gpt-image-2.6-flare",
        "prompt": "Studio product photo of a glass perfume bottle with a gold cap, soft shadow, no text.",
        "size": "1024x1024",
        "quality": "medium",
        "background": "transparent",
        "output_format": "png",
        "response_format": "b64_json",
    },
    timeout=180,
)

result = response.json()
if response.status_code != 200:
    raise RuntimeError(result["error"]["message"])

with open("perfume.png", "wb") as f:
    f.write(base64.b64decode(result["data"][0]["b64_json"]))

print(result["usage"], result["_devup"])

JavaScript (Node.js)

import { writeFile } from "node:fs/promises";

const response = await fetch("https://api.devupai.com/v1/images/generations", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.DEVUP_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "openai/gpt-image-2.6-flare",
    prompt: "Flat illustration of a delivery rider on a scooter crossing a sunny Algerian street, bright colors.",
    size: "1536x1024",
    quality: "low",
    n: 3,
  }),
});

const result = await response.json();
if (!response.ok) throw new Error(result.error.message);

for (const [i, image] of result.data.entries()) {
  const file = await fetch(image.url);
  await writeFile(`rider-${i + 1}.png`, Buffer.from(await file.arrayBuffer()));
}
console.log(result._devup);

Response

{
  "created": 1794316800,
  "data": [
    {
      "url": "<image-url>"
    }
  ],
  "size": "1536x1024",
  "quality": "low",
  "output_format": "png",
  "background": "auto",
  "usage": {
    "input_tokens": "<tokens>",
    "input_tokens_details": { "text_tokens": "<tokens>", "image_tokens": 0 },
    "output_tokens": "<tokens>",
    "output_tokens_details": { "text_tokens": 0, "image_tokens": "<tokens>" },
    "total_tokens": "<tokens>"
  },
  "_devup": {
    "cost_dzd": "<cost_dzd>",
    "balance_dzd": "<balance_dzd>",
    "request_id": "req_<id>"
  }
}

• size, quality, output_format and background are the values the image was made with, defaults included.
• usage is the token count the request was billed on.
• data[i].url is a signed link. Download the image right away rather than storing the link. Send "response_format": "b64_json" to receive the image in the response instead.
• _devup gives:
  • cost_dzd: what the request cost;
  • balance_dzd: your remaining balance;
  • request_id: the id to quote to support.

Editing images

Send the images to POST /v1/images/edits. Up to 16 images (PNG, JPEG or WebP) can be sent as files, https links or data URIs.

• The first image is the one to edit.
• The others are references: a face, a product, an outfit, a style.

Change one thing, keep the rest

curl -X POST 'https://api.devupai.com/v1/images/edits' \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -F model="openai/gpt-image-2.6-flare" \
  -F prompt="Remove the flower from his hand. Keep his face, the blue cap, the clothes, the background and the lighting exactly the same." \
  -F complexity="low" \
  -F "image[]=@man-with-flower.png"

Point at the change with markup

markup is a transparent PNG the size of the first image. You draw on it (for example, a circle around an object), and the prompt says what to do there. markup and mask cannot be sent together.

Before and after a markup edit: "make the circled vase cobalt blue". Source: OpenAI image prompting guide.

curl -X POST 'https://api.devupai.com/v1/images/edits' \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -F model="openai/gpt-image-2.6-flare" \
  -F prompt="Make the circled vase cobalt blue. Change nothing else." \
  -F "image[]=@kitchen.png" \
  -F "markup=@circle.png"

Edit inside a mask

A mask is a PNG with an alpha channel, the size of the first image. Its transparent area is the part the model may change.

curl -X POST 'https://api.devupai.com/v1/images/edits' \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -F model="openai/gpt-image-2.6-flare" \
  -F prompt="Replace the sky with a warm sunset." \
  -F "image[]=@street.png" \
  -F "mask=@sky-mask.png"

Product cut-outs

A product extracted from a photo onto a transparent background. Source: OpenAI image prompting guide.

curl -X POST 'https://api.devupai.com/v1/images/edits' \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -F model="openai/gpt-image-2.6-flare" \
  -F prompt="Extract the bottle onto a transparent background. Keep its shape, label and colors exactly." \
  -F background="transparent" \
  -F output_format="png" \
  -F "image[]=@shampoo-photo.jpg"

Billing

• What you pay for: the tokens the model reports, at the rates shown at the top of this page:
  • text input (your prompt);
  • image input (the images you send for an edit);
  • image output (the images generated).
• The response shows them: the counts are in usage, and the cost in _devup.cost_dzd.
• What changes the price: quality, size and n, because they change the image tokens. complexity, background and the format do not.
• Before generation: an estimate is reserved on your balance. The part that is not billed is returned.
• When nothing is delivered: a request that returns no image is not charged.
• Explore cheaply. Use quality: "low" and several images with n, then render the one you keep at medium or high.

Errors

Every option is checked before anything is generated. A request the model cannot take returns HTTP 400, and nothing is charged.

A value the model does not offer returns invalid_value, and the message lists what is available:

{
  "error": {
    "message": "`quality` \"ultra\" is not available on this model. Available: low, medium, high.",
    "type": "devup_error",
    "code": "invalid_value"
  }
}

Other cases:

• A combination the model does not accept also returns HTTP 400, and the message says what is allowed. Examples: background: "transparent" with jpeg, output_compression with png, markup together with mask.
• stream: true returns unsupported_parameter: images come back in one response.
• HTTP 402: a request your balance cannot cover, returned before anything is generated or downloaded.

Full reference: Image generation and Errors.

Writing prompts that work

OpenAI's prompting guide for GPT Image recommends:

1. Name the subject and the use. A product photograph, an advertisement, a diagram.
2. Organize long prompts. Use labeled parts: scene, subject, details, constraints.
3. Quote the text you want in the image.
   • Say where it goes and in which style.
   • Spell unusual names letter by letter.
   • Ask for no other text.
4. For edits, say what changes and what stays. Change only the color of the vase. Keep the layout, lighting and labels.
5. Give each image a role. Image 1 is the person, image 2 is the jacket, image 3 is the style.
6. Change one thing at a time, and check the result before the next change.

Example

A product photograph for an online store. A ceramic coffee cup with a blue Kabyle pattern on a light wooden table, soft daylight from the left, shallow depth of field. No text, no logo.

Source: OpenAI image prompting guide.

Flare or Sunburst?

The request is the same on both: switch the model and keep the rest.

About the model

GPT Image 2.6 is OpenAI's image generation family released on 4 November 2026, in two models: Flare, "image generation and editing for fast iteration", and Sunburst, "for detailed visual work".

Both models take text and images as input and return images. Images 2.6 introduced:

• a complexity setting that controls how much the model plans an image;
• markup-guided edits.

OpenAI has not published an architecture or a parameter count.

Benchmarks

On the Artificial Analysis text-to-image arena (AA-Image-T2I v2.1), viewers compare two images without knowing which model made which. GPT Image 2.6 Flare holds an Elo of 1228 (95% confidence interval ±12, 6,849 samples). It ranks 2nd, at the time of writing.

The arena scores are measured at OpenAI's max quality level.

Live leaderboard: Artificial Analysis text-to-image.

Best use cases

• E-commerce: product photos, transparent cut-outs and variations for a store or a catalog.
• Ads and social posts: visuals with your headline written in the image.
• Fast drafts: several directions with n at low quality, before the final render.
• Photo edits: remove an object, recolor one item, replace a background, keep the rest.
• Mockups and diagrams: app screens, slides, explainers with readable labels.

Limitations

• Three sizes on this model: 1024×1024, 1536×1024 and 1024×1536.
• Three quality levels: low, medium and high.
• PNG, WebP and JPEG output. Animated and vector outputs are not available on this model.
• Check text and fine detail. Spelling, small lettering and exact layouts are strong but not guaranteed. Review them before publishing, or render the final on Sunburst at high.
• Edits can drift. If the result changes more than asked, lower complexity to low and restate what must stay the same.
• Generated images can reflect societal biases, and requests are subject to OpenAI's content policies. Review prompts and outputs before publishing.

Resources

• GPT-Image-2.6 Flare model page (OpenAI)
• Image generation guide (OpenAI)
• Image prompting guide (OpenAI)
• Artificial Analysis: text-to-image leaderboard
• DEVUP AI image generation documentation