ChatGPT Images 2.5: Flare vs Sunburst and an operational playbook for cost, latency, provenance

ChatGPT Images 2.5: Faster, more precise, but not the same for everyone

On Sep 9, 2026, OpenAI announced ChatGPT Images 2.5: two new image models (GPT-Image-2.5 Flare and GPT-Image-2.5 Sunburst), higher quality tiers, faster generation for many use cases, in-chat creative tools, and layered provenance measures. OpenAI also said users now generate more than three billion images per week through ChatGPT and its image models, a company claim that shows how quickly image AI has moved into production and why small gains in speed, cost, and edit quality matter for teams that operate at scale.

Why you should care: if your organization plans to automate marketing creative, produce product imagery, or use AI-generated visuals in user-facing systems, Images 2.5 changes three operational levers you’ll watch every month: latency, per-image cost, and provenance/traceability. The defaults are better, but the real impact depends on routing rules, token consumption, and how you validate outputs.

Quick summary of what changed

Two model variants: GPT-Image-2.5 Flare (default, faster) and GPT-Image-2.5 Sunburst (stronger, more precise, slower).
New quality tiers: adds “xhigh” and “max” above the prior “high.”
Pricing model: remains token-based (OpenAI lists $8 per 1M image input tokens and $30 per 1M image output tokens on its pricing page). Per-image cost varies because different quality tiers and models use different token counts.
Workflow UX: in-chat Sketch (activate via the @Sketch command), templates, shareable prompts, and commenting to support iterative, team-based creative work.
Provenance: OpenAI applies layered provenance, C2PA metadata plus an invisible watermark (reported to be DeepMind’s SynthID), to images generated in ChatGPT, Codex, and the API.

Practical playbook, what to run first (do these before wide rollout)

Cost benchmark (run 50-100 samples): send representative prompts at each quality tier and record input_token and output_token counts from the API response. Compute per-image cost with the formula below to estimate realistic $/image for your workload.
Latency SLOs: measure median and 95th-percentile latency for Flare and Sunburst under representative loads and from the regions where your users run the service.
Edit-preservation test: pick a set of iterative masked edits (logos, background swaps) and check whether unchanged regions truly remain untouched; quantify with simple pixel-difference metrics or PSNR over 30-50 runs.
Provenance validation: download generated files, inspect C2PA manifests (with exiftool or equivalent), and verify the presence of any invisible watermark detection artifacts per vendor guidance.
Routing check: if you use the ChatGPT UI, compare outputs from Chat and Work modes using identical prompts to detect which model the UI is routing to, don’t assume the UI selects Sunburst by default.

Pricing mechanics, simple arithmetic, big consequences

Token billing for images works like this:

Per-image cost = (input_tokens × $8 + output_tokens × $30) ÷ 1, 000, 000

“Input tokens” cover the tokenized prompt and any image inputs you send; “output tokens” are the tokens the model emits to represent the generated image. Because output tokens often dominate the bill at higher quality tiers, small differences in output-token counts can multiply your monthly bill.

Worked example (from early reporting): a 1024×1024 image at the “max” tier that produced ~7, 024 output tokens costs approximately:

(7, 024 × $30) ÷ 1, 000, 000 ≈ $0.21072 → roughly $0.21 per image (output-token dominated; input tokens add a small incremental amount).

Example per-image figures cited in tests and documentation for 1024×1024 images (illustrative):

low: about $0.006
high: about $0.053
max: roughly $0.21 (with ~7, 024 output tokens)

Note two operational caveats. First, Flare and Sunburst share the same per-token prices, but early tests report Sunburst often ends up costing more per image because it typically emits more output tokens. That explanation is an observed hypothesis from early tests and should be verified against your own token-count measurements. Second, Images 2.5 currently does not list a cheaper batch rate the way the predecessor did, so if you produce very high volumes that absence affects budgeting and deserves a direct check on the pricing page for any updates.

Workflow features that shift where humans add value

Sketch (@Sketch): quick visual seeds in chat for composition and layout. Business use: rapid social-ad creative comps your non-design team can create and iterate on before a designer refines them.
Templates: repeatable prompts for posters, ads, thumbnails, and more. Business use: governance and brand consistency when non-specialists generate assets at scale.
Shareable prompts and commenting: reproducibility and feedback loops useful for distributed teams to standardize creative direction and audit prompt provenance.
Finer editing behavior: Images 2.5 emphasizes iterative edits that preserve unchanged regions, but the degree of preservation differs between models and modes. Test this for logos and product shots.

Provenance: layered, useful, but not invincible

OpenAI’s stated approach combines embedded C2PA metadata and an invisible watermarking scheme (reported to be SynthID) to make generated images traceable. That layered strategy makes sense. Metadata alone can be stripped and invisible watermarks can be degraded by transformations. Together they raise the bar for casual misuse.

Practical caveats and mitigations:

Metadata can be removed by simple file processing. Invisible watermarks can be weakened by aggressive edits, recompression, or format changes.
If provenance matters for compliance, rights management, or moderation, build programmatic checks into your ingestion pipeline: validate C2PA manifests (using established tools) and run watermark-detection checks where vendor tools exist.
Treat provenance as a signal, not a guarantee. Combine automated detection with policy rules and human review where necessary.

Model routing: the uncertain operational detail

The API exposes explicit model selection, so developers can pick Flare or Sunburst when they call the models directly. The ChatGPT UI does not clearly expose a model selector for every user scenario. Early reports indicate Chat mode and Work mode may route differently. In limited tests, Work mode preserved edits more reliably, while Chat mode appeared to use the weaker/default model more often.

That behavior is not documented in a way that guarantees consistency across accounts and tenants. Actionable steps:

Assume the UI may route requests to different model variants by default; don’t assume Sunburst unless you verify it.
To confirm routing, generate sets of identical prompts in Chat and Work modes, record token counts and latencies, and compare outputs. On the API, select models explicitly to control cost and quality.
If model selection matters to SLAs or creative fidelity, prefer the API where you can lock a model choice and measure costs precisely.

Test prompt used in reported Work-mode experiments (attributed to Maximilian Schreiner):

“A hyper-realistic DSLR photo. A monkey holding a pink banana is sitting on a tiger in the foreground. In the background, a HORSE is RIDING AN ASTRONAUT. The astronaut is underneath, like a living “spacesuit horse saddle, ” and the HORSE is clearly on top, in control, as the rider. Make it 100% unambiguous: the HORSE is the rider and the ASTRONAUT is being ridden, NOT the other way around. High resolution, sharp focus, realistic lighting.”

How the new models rank (for now)

Arena’s text-to-image leaderboard lists GPT-Image-2.5 Sunburst and Flare at the top with “Preliminary” labels and relatively small vote counts compared with older entries. The snapshot reported shows:

GPT-Image-2.5 Sunburst: score 1421, ~3, 100 votes
GPT-Image-2.5 Flare: score 1399, ~2, 900 votes
GPT-Image-2 (predecessor): score 1381, ~78, 700 votes

Interpretation: small-sample human voting is volatile. Preliminary labels and low vote counts mean ranks can shift as more evaluations arrive. Treat Arena scores as an early signal, not definitive proof of superiority.

Practical guidance for teams deploying Images 2.5

Measure before you budget: run the cost benchmark above to generate an empirical $/image estimate for your prompts, vendors’ example figures rarely match production workloads.
Protect brand assets: use templates and shareable prompts to codify brand tone and reduce inconsistent ad hoc outputs from distributed teams.
Automate provenance checks: verify C2PA manifests and watermark detection as part of your content ingestion and audit trails.
Expect routing variability: validate whether the ChatGPT UI routes to Flare or Sunburst for your tenant; prefer API control for predictable costs and behavior.
Plan for quality tiers: reserve “max” or “xhigh” for final assets where the incremental cost is justified; use Flare or lower tiers for drafts and bulk iterations.

Key takeaways, questions your CFO or CMO will ask

How much does an image cost with Images 2.5?

OpenAI lists token prices of $8 per 1M input tokens and $30 per 1M output tokens. Per-image costs vary with token usage; examples include roughly $0.006 (low), $0.053 (high), and ~$0.21 (max with ~7, 024 output tokens). Run a 50-100 sample benchmark across your prompts to estimate a realistic $/image.
Which model is faster, Flare or Sunburst?

Flare is the faster/default variant; OpenAI claims the faster variant reduces latency by up to 50% versus Images 2.0. Sunburst prioritizes precision and typically takes longer. Validate median and 95th-percentile latency for your region and prompts.
Can I choose Flare or Sunburst in ChatGPT’s UI?

The API allows explicit model selection. The ChatGPT UI’s routing is not fully exposed and appears to vary between Chat and Work modes; test your tenant to confirm which variant your users hit and prefer the API when you need consistent model selection.
Are generated images labeled so I can prove origin?

OpenAI states it applies C2PA metadata and an invisible watermark (reported as SynthID) to generated images, creating a layered provenance approach. This improves traceability but isn’t foolproof, combine automated provenance checks with policy and manual review where required.
What immediate tests should my team run?

Run three tests in parallel: (1) cost benchmark recording input/output tokens for 50-100 prompts; (2) latency and stability test measuring median and 95th-percentile response times for Flare and Sunburst; (3) edit-preservation trial using masked edits and pixel-difference metrics. Add provenance validation (C2PA manifest + watermark detection) to your pipeline if traceability matters.

Images 2.5 tightens performance and tooling around large-scale image generation. For many teams it will raise productivity: faster defaults, a higher quality ceiling, and better in-chat primitives for collaborative creative work. The catch is operational. Token consumption, per-image cost, UI routing, and provenance limits determine real-world usability. Measure those things early, push the numbers into a P&L line item, and you’ll get a far more accurate ROI than vendor headlines alone provide.

Additional reading

Error extracting content