Sunburst vs Flare: Which GPT Image 2.5 Variant to Use
Sunburst and Flare are the two halves of GPT Image 2.5. They share a price sheet, an API surface and — as far as anyone writing prompts is concerned — a language. They differ in what they optimise: Sunburst is documented as the most capable model for generation and editing, Flare as the fastest for high-quality everyday generation. The right mental model is not “good vs cheap” but “finish vs explore”.
Positioning from official docs; routing advice is editorial
Updated 2026-09-10. The model names, IDs, endpoints, quality settings and pricing below come from the official OpenAI model pages for gpt-image-2.5-sunburst and gpt-image-2.5-flare. Neither page publishes head-to-head speed or quality measurements, and PicGens has not run a controlled comparison. The category routing table is a starting heuristic to test against your own work, not a measured result.
What each variant is for
GPT Image 2.5 Sunburst
gpt-image-2.5-sunburst
Sunburst is the variant to reach for when the image has to be right rather than merely fast: dense multi-panel layouts, in-image typography that has to survive a client review, and edits that must respect the parts of a photo you did not ask it to touch.
Documented
- Described on its model page as the most capable model for image generation and editing.
- Accepts text and image inputs; returns images.
- Exposed through both the v1/images/generations and v1/images/edits endpoints.
- Supports inpainting (masked edits on an existing image).
- Listed pricing: $5 / 1M text input tokens ($1.25 cached), $8 / 1M image input tokens ($2 cached), $30 / 1M image output tokens.
GPT Image 2.5 Flare
gpt-image-2.5-flare
Flare is the exploration engine. It is documented as the fastest model in the family for everyday generation, and it exposes an explicit quality ladder, so the same prompt can be run cheaply while you are still deciding what the picture should be and then re-run at a higher setting once it is decided.
Documented
- Described on its model page as the fastest model for high-quality, everyday image generation.
- Accepts text and image inputs; returns images.
- Quality settings documented as low, medium, high, xhigh, max and auto.
- Supports inpainting and is available on the generation and edit endpoints.
- Listed pricing: $5 / 1M text input tokens ($1.25 cached), $8 / 1M image input tokens ($2 cached), $30 / 1M image output tokens.
The tradeoff is time, not money
Both model pages list the same token prices: $5 per million text input tokens ($1.25 cached), $8 per million image input tokens ($2 cached), and $30 per million image output tokens. Nothing on the price sheet says “the capable one is more expensive”. What differs is how much compute an image consumes and how long you wait for it — which converts into cost only through token count, and into frustration immediately.
Flare adds a second lever that Sunburst’s documentation does not advertise: an explicit quality ladder from low through medium, high, xhigh and max, plus auto. That ladder is the real argument for making Flare your default entry point. The same prompt can be run twenty times at a low setting while you are still arguing about the composition, then once at a high setting when you are not — without switching models, endpoints or prompt text.
Sunburst earns its place at the other end of the funnel. It is the variant documented as most capable for editing, and editing is where per-run speed matters least: you are not exploring, you are fixing three specific things in an image someone has already approved in outline. Both variants support inpainting through v1/images/edits, so you can mask a region and describe only the change rather than regenerate a frame you were happy with.
Which to pick, by category
Most real projects use both. The useful question is not “which variant” but “which variant at which stage”, so the table splits drafting from finishing.
| Category | Typical work | Draft on | Finish on | Why |
|---|---|---|---|---|
| Poster & campaign layout | Multi-panel grids, ad storyboards, launch keyvisuals | Flare | Sunburst | Panel count, flow and hierarchy are decided over many cheap runs; the final has legible branding and must survive a client review. |
| UI, icons & app assets | App icons, empty-state art, feature illustrations | Flare | Flare | Strict geometric contracts held well even on short prompts, and asset sets are volume work. Escalate only when a specific icon keeps failing. |
| Product & packshots | Bottles, cosmetics, food, e-commerce whites | Flare | Sunburst | Label accuracy and material realism are the deliverable, and packshots are usually edited afterwards rather than regenerated. |
| Photo editing & retouching | Background swaps, object removal, masked fixes | Sunburst | Sunburst | Documented as the most capable variant for editing. Editing work has no cheap-draft phase — the reference image already exists. |
| Illustration & editorial art | Watercolour, ink, poster art, book covers | Flare | Flare or Sunburst | Style fidelity and negative constraints held on the illustration case. Escalate only when fine linework or lettering is failing. |
| Photoreal scenes & dioramas | Miniatures, dense environments, texture-forward stills | Flare | Sunburst | Dense scenes are where extra detail helps most and where crowding risk is highest, so the final deserves the capable variant and a tightened prompt. |
The category observations behind this table come from four single-run reproductions documented on the GPT Image 2.5 prompt page — one poster, one icon, one diorama and one illustration. Four samples is a hypothesis, not a finding.
A default workflow that uses both
- Explore on Flare, low quality. Ten to twenty runs to settle subject, layout and palette. Judge composition only; ignore texture and lettering at this stage.
- Lock the prompt. Convert everything you liked into explicit constraints — panel count, canvas coverage, quoted text, background colour, aspect ratio. This is the step that makes the rest reproducible.
- Re-run on Flare, high or max. Same text, higher setting. Often this is already the deliverable, particularly for icons, illustration and social work.
- Escalate to Sunburst only on a named failure. Illegible brand text, a broken layout contract, a material that reads as plastic. Escalating without a named failure just spends time.
- Edit on Sunburst, never restart. Mask the region, describe only the change. Regenerating a whole frame to fix one corner throws away every decision you already approved.
- Record what you did. Variant, quality setting, date and prompt hash. Without that, a future model update is uninterpretable.
Frequently asked questions
- Is Sunburst always better than Flare?
- No. Sunburst is documented as the most capable variant for generation and editing, but capability you do not need is latency you pay for. For volume work with a settled composition — icon sets, social imagery, batch variations — Flare at a high quality setting is usually the better tool, and neither page publishes measurements that would settle it in general.
- Does Flare produce lower-quality images?
- Its documentation positions it for high-quality everyday generation, and it exposes quality settings from low through max. A Flare image at
maxis not the same thing as a Flare image atlow, so compare like with like before concluding anything about the variant. - Do I need different prompts for Sunburst and Flare?
- No. They share prompt language, accept the same text and image inputs, and are served from the same generation and edit endpoints. Keeping one prompt across both is what makes the draft-on-Flare, finish-on-Sunburst workflow practical — you are changing the route, not the request.
- Which variant should I use for photo editing?
- Sunburst, by its documented positioning as the most capable model for editing. Both variants support inpainting, so if access or throughput pushes you to Flare, the technique is unchanged: mask the region and describe only what should differ inside it.
- Is one of them cheaper per image?
- Their published token pricing is identical, so per-image cost is a function of tokens consumed rather than of the variant name. The only reliable answer is the one you measure by running your own prompts and counting tokens in your own account.
- Where can I see real GPT Image 2.5 output?
- The GPT Image 2.5 prompt page shows four complete prompts re-run against their original images, with the full prompt text copyable. Note the disclosure there: those are single, uncontrolled samples whose model IDs were never reported by the tool that produced them.
Reproductions and case notes from awesome-gpt-image-2 (MIT) by freestylefly.