GPT-Image-2.5 Flare vs Sunburst vs gpt-image-2: which to pick, and what each image costs

OpenAI shipped ChatGPT Images 2.5 on September 8, 2026, with two API models: gpt-image-2.5-flare and gpt-image-2.5-sunburst. Both bill at the same per-token rates as gpt-image-2, and both share a single entry in OpenAI’s pricing calculator. So the per-token table won’t help you choose. What changed is the quality ladder underneath it, and the relabel moves the price of a quality: "high" image by about 4x.

This is the decision page: per-token rates, per-image estimates for all five 2.5 quality levels beside the gpt-image-2 numbers, the label remap, a 10,000-image monthly budget, the “2x pricing” rumor, and a migration checklist. If you want request syntax first, read how to use the gpt-image-2.5 API. The OpenAI pricing page is the source for every rate below. Every per-image figure is a calculator estimate, since OpenAI warns that token consumption “can differ by model and quality setting”; your bill comes from usage.output_tokens in the response.

Per-token rates: identical across all three

OpenAI’s pricing page lists the same Standard-tier rates for both 2.5 models, and each model page states that its “Token rates match GPT Image 2”. Here is the full table, including the Batch row that caused confusion at launch.

All figures are per 1M tokens. Output is image-only on every model here, so text output never appears on a bill.

About the “2x pricing” claim in some early coverage: it came from comparing the 2.5 Standard row against the gpt-image-2 Batch row, which is a 50% discount. Line up Standard against Standard on the pricing page and every rate is unchanged.

What each image costs at every quality level

Per-token parity is where the similarity ends. OpenAI’s calculator (read 2026-09-09) reports these image output token counts under one shared entry, “GPT Image 2.5 (Sunburst and Flare)”. Cost is tokens times $30 per 1M, output tokens only.

Here is the gpt-image-2 table from the same docs page, for the same sizes.

Two things stand out. The landscape size is cheaper than the square in every row, a pattern OpenAI’s docs call out. And the 2.5 high row is nowhere near the gpt-image-2 high row. That is the relabel.

Prompt text and reference images bill on top. A reference image sent to images/edits costs image input tokens at $8 per 1M; OpenAI does not publish the input token count per image, so read it from usage.input_tokens.

The quality ladder was relabeled

Match the token budgets and the mapping is clear. On 2.5, high is 1,756 output tokens, the budget gpt-image-2 spent at medium. On 2.5, max is 7,024 tokens, the budget gpt-image-2 spent at high. low is unchanged at 196 tokens.

So a migration that keeps quality: "high" gets about 4x cheaper per image and renders at the old medium budget. One that wants the old high budget must move to max, at effectively the old price. xhigh is a new middle rung with no gpt-image-2 equivalent.

The monthly math, derived from OpenAI’s calculator estimates at 1024x1024:

• 10,000 images at 2.5 high: 10,000 x $0.05268 = $526.80
• 10,000 images at gpt-image-2 high: 10,000 x $0.211 = $2,110
• 10,000 images at 2.5 max: 10,000 x $0.21072 = $2,107.20, effectively the same as old high
• Streaming with partial_images: 3 adds 300 tokens, or $0.009 per image, since each partial costs 100 image output tokens

Flare vs Sunburst: what the premium buys

Both models share the calculator entry, so the documented token counts are identical. Sunburst does not cost more per image; the premium is time. OpenAI’s launch post aims Flare at “high-volume generation” and Sunburst at “premium visual workflows that benefit from tighter control across edits”. The docs compress it to one line: “Choose Sunburst for workflows where editing precision matters most, and Flare for fast, high-quality everyday image generation.”

Community signal, labeled as such:

• In the HN thread, user jjcm, who reported roughly 50,000 images through gpt-image-2 for an AI UI design tool, said average latency “held at around 104s” on gpt-image-2 and 2.5 images “are coming in at around 35-40s”. One data point, one workload; OpenAI’s own claim is “up to 50%” lower latency.
• The Arena text-to-image leaderboard (community votes, updated September 7, 2026) ranks Sunburst first at 1421, Flare second at 1399, gpt-image-2 at medium third at 1381, then Microsoft’s mai-image-2.6 at 1331; Nano Banana 2 sits at 1261. On the image-edit leaderboard the gap widens: Sunburst 1520, Flare 1491, gpt-image-2 1461. Crowd preference scores, not OpenAI benchmarks.

The decision rule: default to Flare. Switch to Sunburst for multi-turn edit workflows where a reference subject must survive several rounds of instructions. The Arena gap is 22 points on text-to-image and 29 on edits, which supports OpenAI’s framing that edits are where Sunburst earns its wait. If that gap does not show up on your own prompts, you are paying latency for nothing.

When gpt-image-2 still makes sense

Batch discounts. The pricing page’s Batch tab lists only gpt-image-2, at $15 per 1M output tokens; whether /v1/batch accepts the 2.5 ids is undocumented at time of writing . If your workload tolerates the Batch API’s turnaround, gpt-image-2 at Batch medium (half of $0.053) undercuts 2.5 high at Standard rates for the same token budget.

Pinned snapshots. gpt-image-2-2026-04-21 has shipped since April with no deprecation notice as of 2026-09-09. If your pipeline depends on output someone has visually reviewed, a snapshot that is not changing is a feature; our gpt-image-2 API guide covers its parameters. For a cross-vendor anchor, compare Nano Banana 2 API pricing and the FLUX.2 API at the same output size; 2.5 high at roughly five cents per square image is the number to beat.

Migration checklist from gpt-image-2 to 2.5

• Swap the model id. gpt-image-2 becomes gpt-image-2.5-flare (or -sunburst); pin gpt-image-2.5-flare-2026-09-08 for stable output.
• Remap quality labels. Old medium becomes new high, old high becomes new max, low stays low. Do it in config, not per call site.
• Consider xhigh and max. Both are new in 2.5; xhigh at 3,122 tokens sits between the old medium and old high budgets.
• Drop thinking assumptions. The 2.5 docs do not describe a thinking parameter; remove it from templates instead of assuming it is accepted or ignored .
• Re-measure usage. Log usage.output_tokens and usage.input_tokens for a week of real prompts; the calculator numbers are estimates.
• Check Batch eligibility. If you rely on the 50% Batch discount, confirm /v1/batch accepts the 2.5 ids before you cut over .

Compare all three models in Apidog with one saved request

Apidog is an API client and testing platform. It sends the images/generations request and asserts on the response; it does not generate images or run the model. That makes it the place to settle Flare vs Sunburst vs gpt-image-2 with your own prompts.

Build one request to POST https://api.openai.com/v1/images/generations with the model as a variable, then create three environments named flare, sunburst, and gpt-image-2. Each sets {{model}} and stores OPENAI_API_KEY as an environment variable, so the key never lands in the request body.

{
  "model": "{{model}}",
  "prompt": "Product photo of a matte black ceramic mug on a walnut desk, soft window light",
  "size": "1024x1024",
  "quality": "high",
  "output_format": "jpeg",
  "output_compression": 80
}

Add a post-processor script that records the numbers and fails the run if the token budget slips:

const body = pd.response.json();
const tokens = body.usage.output_tokens;
pd.environment.set("last_output_tokens", tokens);
pd.environment.set("last_wall_clock_ms", pd.response.responseTime);
pd.test("output tokens within budget", () => {
  pd.expect(tokens).to.be.below(2000);
});

Run the request in each environment. Apidog’s response time is your wall-clock number, last_output_tokens is the measured count to set against the calculator’s 1,756, and the gap between the flare and sunburst runs is the Sunburst premium for your prompt. The same environment switch works for the images/edits multipart call; assert on usage.input_tokens there to learn what a reference photo costs. Download Apidog to run the comparison before you change production code.

FAQ

Is gpt-image-2.5 more expensive than gpt-image-2? Per token, no. Both 2.5 models and gpt-image-2 Standard bill $30 per 1M image output tokens, $8 per 1M image input, and $5 per 1M text input. Per image, a 2.5 high request costs about $0.053 at 1024x1024, versus $0.211 for gpt-image-2 high.

Does Sunburst cost more than Flare? No. Both models share one calculator entry, so the documented token counts are identical at every quality level and size. Sunburst’s premium is longer generation time, which OpenAI calls an “extra level of precision” for edit-heavy work.

Which quality setting replaces my old gpt-image-2 high? max. It uses 7,024 tokens at 1024x1024, the same budget as gpt-image-2 high, and costs $0.21072 by the calculator. Leave high in place and you get the old medium budget at about a quarter of the price. The pillar post on ChatGPT Images 2.5 covers what else changed.

Is there a free way to try Images 2.5 before paying for the API? Yes. The model is on every ChatGPT tier with per-plan generation caps, covered in how to use ChatGPT Images 2.5 for free. The API has no free tier for image endpoints; low quality at about $0.006 per square image is the cheapest real path.

Which model to pick

Flare for anything high-volume or latency-sensitive, at high for most work and max when the old gpt-image-2 high look is a requirement. Sunburst for multi-turn edits where a reference subject must survive, after a side-by-side on your prompts; gpt-image-2 for Batch jobs and pinned pipelines you are not ready to re-review. Whatever you choose, read usage.output_tokens from real responses; three environments in Apidog and one saved request give you that number in an afternoon.