GPT Image 2.5 Sunburst and Flare: How to Use OpenAI's New Models

Last updated: October 17, 2026

GPT Image 2.5 Sunburst (gpt-image-2.5-sunburst) and GPT Image 2.5 Flare (gpt-image-2.5-flare) are OpenAI's image models released on September 8, 2026 for the Image API and the Responses API image generation tool. Sunburst is aimed at editing precision, Flare at fast everyday generation, and both add new xhigh and max quality tiers while billing at the same per-token rates as GPT Image 2. Our verdict: for new work, default to Flare for generation and reach for Sunburst when you are editing an image and the pixels you did not ask to change need to stay put - but do not reuse your GPT Image 2 cost estimates, because OpenAI says token use per image can differ by model and quality setting. Start from the image generation guide's new 2.5 output-token estimator, then confirm with the usage on real requests.

This is the practical walkthrough: model IDs, a model-picking rule, four TypeScript examples type-checked against openai@7.36.0, how cost actually adds up, and the traps worth knowing before you ship. If you are building a prompt workflow on top of this, our piece on treating GPT Image prompt libraries as production build artifacts covers that side; this post stays on the API.

Official Sources#

What shipped#

Two new models, each with a dated snapshot:

Both work on the same two surfaces as GPT Image 2:

• Image API - POST /v1/images/generations and POST /v1/images/edits.
• Responses API - POST /v1/responses with the image_generation tool.

Both accept text and image input and return images. Both add two quality tiers above high: the full list for the 2.5 models is low, medium, high, xhigh, max and auto, with auto as the default. Earlier GPT Image models top out at high.

Per-token pricing and rate limits are identical to gpt-image-2. The Free tier is not supported. The paid tiers (OpenAI simplified usage tiers to Build, Launch and Grow on October 6, 2026) are:

Here is how the three current GPT Image models line up on OpenAI's own model-page labels:

The performance and speed rows are OpenAI's labels, not independent benchmarks. Treat them as a starting hypothesis and measure on your own prompts.

Which model to pick#

The changelog gives the clearest steer: use Sunburst "for workflows where editing precision matters most" and Flare "for fast, high-quality everyday image generation." That maps to a simple rule. If you are changing an existing image and care about what stays the same, start with Sunburst. If you are generating from text, start with Flare, and only move to a higher tier or the other model when a specific output disappoints.

%% title: Picking a GPT Image model
flowchart TD
  A["New image task"] --> B{"Editing an existing image?"}
  B -- "Yes, precision matters" --> S["gpt-image-2.5-sunburst"]
  B -- "No, generate from text" --> C{"Latency-sensitive or high volume?"}
  C -- Yes --> F["gpt-image-2.5-flare"]
  C -- "No, final hero asset" --> D{"Need xhigh or max?"}
  D -- Yes --> F2["Flare or Sunburst at xhigh/max"]
  D -- No --> E["Either 2.5 model at high"]
  S --> P["Pin dated snapshot in prod"]
  F --> P
  F2 --> P
  E --> P

What about gpt-image-2? It is still a documented, supported model with the same rate limits and prices, and nothing about this release breaks an existing integration. For new work, though, OpenAI is direct about it. The image generation guide's "Earlier GPT Image models" section says: "For new integrations, use one of the GPT Image 2.5 models described above." gpt-image-2 does also have a published per-image dollar table at three sizes, which we reproduce as a labelled reference in the cost section below.

Prerequisites#

• An OpenAI API key on the Build tier or above. The Free tier cannot call these models.
• Your organization may need to complete API Organization Verification before GPT Image models work.
• Node 18+ and npm i openai@7.36.0, or Python with pip install openai==3.34.0. Both SDK versions include the two model IDs, their 2026-09-08 snapshots and the xhigh / max quality values in their types.

A note on how the code below was checked: every TypeScript example was type-checked with npx tsc --noEmit (strict mode, moduleResolution: bundler) against openai@7.36.0 and typescript@7.0.2. As a sanity check, passing quality: "ultra" fails compilation, so the SDK really does enforce the new tier names. The Python snippet passed py_compile and an import check against openai 3.34.0. We did not make live API calls for this post, so the snippets are verified against the SDK contracts, not against real outputs.

Step 1: Generate with Flare through the Image API#

The quickest test is a curl call. The Image API always returns base64 for GPT image models (the old response_format parameter is deprecated for them), so pipe the result through jq and base64:

curl -s https://api.openai.com/v1/images/generations \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-image-2.5-flare","prompt":"Isometric illustration of a developer desk with three monitors, flat colors, no text","quality":"high","size":"1536x1024","output_format":"jpeg"}' \
  | jq -r '.data[0].b64_json' | base64 --decode > desk.jpg

jpeg is used here because the guide notes it is faster than the default png when latency matters. jpeg and webp also accept output_compression from 0 to 100.

For real pipelines, a useful pattern is draft-then-final: iterate on the prompt at low, then re-render the winner at a higher tier. This TypeScript version also uses a custom size and logs what the API actually did:

import fs from "node:fs";
import OpenAI from "openai";

const client = new OpenAI();

async function render(prompt: string, quality: "low" | "high" | "xhigh" | "max", file: string) {
  const result = await client.images.generate({
    model: "gpt-image-2.5-flare",
    prompt,
    quality,
    size: "1536x864",
    output_format: "webp",
    output_compression: 80,
  });
  const b64 = result.data?.[0]?.b64_json;
  if (!b64) throw new Error("No image returned");
  fs.writeFileSync(file, Buffer.from(b64, "base64"));
  console.log(file, result.quality, result.size, result.usage?.output_tokens ?? "n/a");
}

const prompt = "Isometric illustration of a developer desk with three monitors, flat colors, no text";
await render(prompt, "low", "draft.webp");
await render(prompt, "max", "final.webp");

Three details are worth calling out:

• Custom sizes. The recommended sizes are 1024x1024, 1536x1024 and 1024x1536, but you can send any WIDTHxHEIGHT string that follows the rules: both edges are multiples of 16, the aspect ratio is between 1:3 and 3:1, no edge exceeds 3840px, and the total pixel count is between 655,360 and 8,294,400. 1536x864 is a 16:9 frame that fits. Anything above 2560x1440 is marked experimental.
• The response echoes effective settings. ImagesResponse includes quality and size, which tells you what auto resolved to.
• usage is optional in the type. Guard it with optional chaining, and log it. You will need those numbers for budgeting (see "What it costs").

The Python equivalent:

import base64
from openai import OpenAI

client = OpenAI()

result = client.images.generate(
    model="gpt-image-2.5-flare",
    prompt="Isometric illustration of a developer desk with three monitors, flat colors, no text",
    quality="xhigh",
    size="1536x864",
)

if not result.data or not result.data[0].b64_json:
    raise RuntimeError("No image returned")

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

Step 2: Precise edits with Sunburst#

Sunburst is the model OpenAI points at editing workflows. A masked edit through /v1/images/edits looks like this:

import fs from "node:fs";
import OpenAI, { toFile } from "openai";

const client = new OpenAI();

const result = await client.images.edit({
  model: "gpt-image-2.5-sunburst",
  image: await toFile(fs.createReadStream("product.png"), null, { type: "image/png" }),
  mask: await toFile(fs.createReadStream("mask.png"), null, { type: "image/png" }),
  prompt: "Replace only the label on the bottle with a plain matte black label. Keep lighting, reflections and background unchanged.",
  quality: "xhigh",
  safety_identifier: "user_7f3a9c",
});

const b64 = result.data?.[0]?.b64_json;
if (!b64) throw new Error("No image returned");
fs.writeFileSync("product-edited.png", Buffer.from(b64, "base64"));

The limits that matter for edits:

• Inputs. Up to 16 input images, each png, webp or jpg and under 50MB. The prompt can run to 32,000 characters, and n can be 1 to 10.
• Masks. The API reference (mirrored in the mask doc comment in openai@7.36.0) says the mask must be a valid PNG under 4MB with the same dimensions as the image, and the guide adds that it needs an alpha channel. Transparent areas mark what to change. With several input images, the mask applies to the first one. One discrepancy: the guide's "Mask requirements" section gives a looser figure, saying the image and mask must be the same format and size and "less than 50MB in size." Design for 4MB, the stricter of the two.
• Masks are guidance, not a stencil. The guide is explicit that masking is prompt-based: the model uses the mask as guidance and may not follow its exact shape. That is why the prompt above says "Replace only the label" and lists what to keep unchanged. Saying it in words matters as much as the mask.
• Skip input_fidelity. The SDK documents high / low for gpt-image-1 and gpt-image-1.5 only and says to omit it for gpt-image-2. Nothing documents it for the 2.5 models, so leave it out.
• safety_identifier. The guide recommends a hashed per-user identifier (128 characters or fewer). The older user parameter is deprecated in favor of it.

Step 3: Multi-turn editing in the Responses API#

The Responses path works differently. You pick a mainline model at the top level, and that model writes the image prompt and calls the image_generation tool. OpenAI's examples use gpt-6-astra as the mainline model (our GPT-6 Astra guide covers that model). The image model goes in the tool's own model field.

This is where the most important trap lives: the tool's model defaults to gpt-image-1. The SDK's doc comment on ImageGeneration.model says "Default: gpt-image-1." If you add the tool and forget the field, you silently get an older model.

%% title: Responses API image tool, two turns
sequenceDiagram
  participant App
  participant Astra as gpt-6-astra
  participant Tool as image_generation tool
  App->>Astra: turn 1 prompt + tool model=flare, action=generate
  Astra->>Tool: revised_prompt
  Tool-->>Astra: image_generation_call result
  Astra-->>App: response.id + base64 image
  App->>Astra: turn 2, previous_response_id, tool model=sunburst, action=edit
  Astra->>Tool: edit image in context
  Tool-->>Astra: image_generation_call result
  Astra-->>App: edited image

The code below generates with Flare on turn one, then switches the tool to Sunburst and forces an edit on turn two:

import fs from "node:fs";
import OpenAI from "openai";

const client = new OpenAI();

function saveFirstImage(output: OpenAI.Responses.ResponseOutputItem[], file: string): boolean {
  for (const item of output) {
    if (item.type === "image_generation_call" && item.result) {
      fs.writeFileSync(file, Buffer.from(item.result, "base64"));
      return true;
    }
  }
  return false;
}

const first = await client.responses.create({
  model: "gpt-6-astra",
  input: "A clean hero illustration of a robot arm assembling a circuit board, white background",
  tools: [{ type: "image_generation", model: "gpt-image-2.5-flare", quality: "high", action: "generate" }],
});
if (!saveFirstImage(first.output, "turn-1.png")) throw new Error("Turn 1 returned no image");

const second = await client.responses.create({
  model: "gpt-6-astra",
  previous_response_id: first.id,
  input: "Change only the circuit board color to deep green. Keep everything else identical.",
  tools: [{ type: "image_generation", model: "gpt-image-2.5-sunburst", quality: "xhigh", action: "edit" }],
});
if (!saveFirstImage(second.output, "turn-2.png")) throw new Error("Turn 2 returned no image");

Notes on this path:

• action is optional. auto (the default) lets the model decide, generate always creates a new image, and edit forces an edit when an image is already in context.
• Multi-turn state comes from previous_response_id, as above, or from passing earlier image generation calls back in the input.
• Prompt rewriting. The mainline model rewrites your prompt, and the text it actually sent is returned as revised_prompt on the image_generation_call. Log it when an output surprises you.
• Input images can be a full URL, a base64 data URL, or a Files API file ID uploaded with purpose vision. The Image API, by contrast, takes the bytes directly.
• Cached input pricing only applies here, on the Responses image tool, not on direct Image API calls.
• Pairing Flare and Sunburst across turns is our pattern, built from documented parameters. OpenAI's docs do not prescribe it. It is a reasonable way to keep drafts fast and edits precise, but measure whether the switch earns its keep on your content.

If you are still on the Assistants API, multi-turn image editing with previous_response_id is one more reason to move; see our Responses API migration guide.

Step 4 (optional): Stream partial images#

For a UI that shows progress, both the Image API and Responses support partial-image streaming with stream: true and partial_images (0 to 3):

import fs from "node:fs";
import OpenAI from "openai";

const client = new OpenAI();

const stream = await client.images.generate({
  model: "gpt-image-2.5-flare",
  prompt: "A lighthouse on a basalt cliff at dusk, painterly",
  stream: true,
  partial_images: 2,
});

for await (const event of stream) {
  if (event.type === "image_generation.partial_image") {
    fs.writeFileSync(`partial-${event.partial_image_index}.png`, Buffer.from(event.b64_json, "base64"));
  } else if (event.type === "image_generation.completed") {
    fs.writeFileSync("final.png", Buffer.from(event.b64_json, "base64"));
  }
}

Each partial image adds 100 image output tokens to the bill.

One inconsistency to flag: the Sunburst and Flare model pages list "Streaming" as not supported, while the image generation guide documents partial-image streaming and uses Sunburst in its streaming examples. The likely reading is that the model page refers to text-style token streaming, but that is our interpretation. Test streaming on your own account before you build a UI that depends on it.

What it costs#

Both 2.5 models bill at GPT Image 2's rates:

Text output is not billed. On the Responses path, the mainline model's own token usage is billed on top of the image costs.

%% title: What a GPT Image 2.5 request bills
flowchart LR
  T["Text input tokens $5/1M"] --> SUM["Request cost"]
  I["Image input tokens $8/1M"] --> SUM
  O["Image output tokens $30/1M"] --> SUM
  P["+100 output tokens per partial"] --> SUM
  M["Mainline model tokens, Responses only"] --> SUM
  C["Cached input discount, Responses tool only"] -.-> SUM
  E["Guide estimator covers this box only"] -.-> O

The key point: equal rates do not mean equal cost per image. The guide's own wording is that "token consumption can differ by model and quality setting," and its advice is to measure with the usage returned on each response.

The guide's 2.5 output-token estimator#

The image generation guide's "Cost and latency" section now has a subsection titled "GPT Image 2.5 and GPT Image 2 output tokens." It is an interactive estimator: pick a model, a quality and a size, and it returns an output-token count and an estimated image output cost at $30 per million tokens. For the 2.5 models it offers low, medium, high, xhigh and max; for gpt-image-2 it offers low to high. That makes it the right first stop when you want to know roughly what an xhigh or max image will cost before you send one.

Read its limits before you budget from it:

• Image output tokens only. The guide states the estimate "Excludes text and image input tokens and streaming partial images." Edits with reference images, long prompts and partial_images all add cost on top.
• No auto. The guide says to use explicit quality and size values because "auto depends on the generated image."
• Sunburst and Flare share one option. The model picker lists a single "GPT Image 2.5 (Sunburst and Flare)" entry, while the same subsection says "The models can use different token counts for the same quality setting." Treat the number as a ballpark for either model, not a per-model figure.

One wording trap: the Sunburst and Flare model pages still say "The GPT Image 2 calculator does not estimate GPT Image 2.5 token consumption." That remains true, but it refers to the older GPT Image 2 pricing calculator, not this estimator.

For reference, here is the predecessor's published per-image cost. These are gpt-image-2 figures from the guide's "Calculating costs" table, not 2.5 figures:

OpenAI does not publish a per-image dollar table like this for Sunburst or Flare; the estimator is the 2.5 equivalent. The practical move is to use the estimator for a first budget, then run a small sample of your real prompts through each model at each tier you are considering, log usage alongside model, quality and size, and only then decide whether xhigh or max belongs in your defaults. We have written before about treating image tokens as a cost line you measure rather than estimate, and that applies directly here.

Two more pricing details: cached input pricing applies only to the Responses image tool, never to direct Image API requests including /v1/images/edits, and cached token counts are not shown in Responses usage, so you cannot confirm the discount from the response itself.

Gotchas and limits#

1. The Responses tool defaults to gpt-image-1. Always set model on the image_generation tool.
2. Pin the snapshot in production. Use gpt-image-2.5-flare-2026-09-08 or gpt-image-2.5-sunburst-2026-09-08 so a future alias update does not change outputs or costs under you.
3. auto quality makes cost hard to predict. It is the default, and the guide's estimator does not cover it. Send an explicit quality in pipelines, and read the echoed quality field when you do use auto.
4. No cached-input discount on /v1/images/edits. Caching is a Responses-tool-only discount.
5. Transparent backgrounds need png or webp. Set background: "transparent" with output_format of png or webp. Transparency is fully supported on both 2.5 models and still in preview on gpt-image-2.
6. jpeg is faster than png when latency matters.
7. Generation can take up to 2 minutes for complex prompts. Run it as background work with a job queue, not inside a request handler with a short timeout.
8. Known weak spots remain. The guide lists precise text placement, consistency of recurring characters or brand elements, and layout-precise composition as areas that can still struggle.
9. Do not auto-retry moderation blocks. A blocked request returns error.type image_generation_user_error with a code such as moderation_blocked. Retrying the same input will not help; change the input or surface the error. The moderation parameter accepts auto (default) or low.
10. Rate limits start low. No Free tier, and Build allows 20 images per minute. Plan concurrency around IPM, not just TPM.
11. Use safety_identifier, not user. Send a hashed per-user ID of 128 characters or fewer.
12. Keep masks under 4MB. The guide's 50MB figure is looser than the API reference; 4MB PNG is the safe limit.

GPT Image 2.5 vs GPT Image 2#

On documented facts, the two generations share a lot: the same per-token prices, the same rate limits, the same size constraints, and the same Image API and Responses surfaces. Moving between them is a model ID change, not a rewrite.

What 2.5 adds:

• The xhigh and max quality tiers.
• Full transparent-background support (preview on gpt-image-2).
• A split by job: Flare is rated "Very fast" where gpt-image-2 is rated "Medium", and Sunburst carries the "Highest" performance label and the editing-precision positioning.

What gpt-image-2 still does well: it is supported and stable, existing pipelines keep working unchanged, and it carries a "Higher" performance rating of its own. It also has a published per-image dollar table at three sizes, alongside its entry in the shared output-token estimator. If a pipeline needs neither the new tiers nor full transparency support, there is no documented deadline forcing a move. For new work, the guide is explicit: "For new integrations, use one of the GPT Image 2.5 models described above."

A migration checklist:

1. Swap the model ID (Flare for generation, Sunburst for edits) and pin the dated snapshot.
2. Get a first estimate from the guide's 2.5 output-token estimator, then re-measure usage per quality tier and size on a representative prompt set. Do not carry over old per-image numbers.
3. Keep quality explicit, and decide deliberately whether any route earns xhigh or max.
4. If you use the Responses tool, confirm the tool model field is set.
5. Drop input_fidelity if you were sending it.

If you are comparing vendors rather than OpenAI generations, our write-up on Grok Imagine Image 2.0 covers xAI's image model and how it is served; we have not run a head-to-head between the two.

FAQ#

What is the difference between GPT Image 2.5 Sunburst and Flare?#

Sunburst (gpt-image-2.5-sunburst) is OpenAI's "most capable model for image generation and editing," rated Highest performance and Medium speed, and positioned for workflows where editing precision matters most. Flare (gpt-image-2.5-flare) is rated Higher performance and Very fast, and positioned for fast, high-quality everyday generation. Both support the same quality tiers, sizes and prices.

Do xhigh and max cost more than high?#

The price per token is the same at every tier, but a higher tier can use more output tokens per image, so the image can cost more. The image generation guide's output-token estimator covers Sunburst and Flare at low through max and gives an output-token and dollar figure for a chosen size. It counts image output tokens only (no text or image input tokens and no partial images), has no auto option, and treats the two 2.5 models as one option even though the guide says token use can differ by model and quality. Use it for a first estimate, then confirm with the usage field on real requests before making xhigh or max a default.

Can I use GPT Image 2.5 in the Responses API?#

Yes. Choose a mainline model at the top level (OpenAI's examples use gpt-6-astra) and set model: "gpt-image-2.5-flare" or "gpt-image-2.5-sunburst" on the image_generation tool. Set it explicitly: the tool defaults to gpt-image-1. You also get multi-turn editing via previous_response_id and the cached-input discount on this path.

Should I migrate from gpt-image-2 now?#

For new integrations, OpenAI's guide says to "use one of the GPT Image 2.5 models," and prices and rate limits match, so you gain the new tiers and full transparency support at the same rates. For existing gpt-image-2 pipelines with tight budgets, there is no forced deadline in the docs; get a first number from the 2.5 estimator and then run a measured sample, because token use per image can differ by model and quality, and the gpt-image-2 per-image table will not tell you what 2.5 costs.

Does GPT Image 2.5 support transparent backgrounds and custom sizes?#

Yes to both. Set background: "transparent" with png or webp output. Custom WIDTHxHEIGHT sizes work when both edges are multiples of 16, the aspect ratio is between 1:3 and 3:1, no edge exceeds 3840px, and the total is between 655,360 and 8,294,400 pixels; sizes above 2560x1440 are experimental.

Sources#

• OpenAI API changelog: https://developers.openai.com/api/docs/changelog
• gpt-image-2.5-sunburst model page: https://developers.openai.com/api/docs/models/gpt-image-2.5-sunburst
• gpt-image-2.5-flare model page: https://developers.openai.com/api/docs/models/gpt-image-2.5-flare
• Image generation guide (cost and latency, output-token estimator, mask requirements, earlier GPT Image models): https://developers.openai.com/api/docs/guides/image-generation
• Image API reference: https://developers.openai.com/api/reference/resources/images
• OpenAI API pricing (image generation): https://developers.openai.com/api/docs/pricing#image-generation
• gpt-image-2 model page: https://developers.openai.com/api/docs/models/gpt-image-2
• openai npm package (v7.36.0 type definitions): https://www.npmjs.com/package/openai

Continue Reading#

• GPT Image 2 Prompt Libraries Are Becoming Production Infrastructure - turn the prompts you send to Flare and Sunburst into reusable, versioned build artifacts.
• GPT-6 Astra release guide - the mainline model OpenAI uses to drive the Responses image tool.
• OpenAI Responses API migration - if you are still on Assistants and need Responses for multi-turn image editing.