# Moving off gpt-image-2: is Sunburst or Flare a drop-in swap?

URL: https://infro.io/blog/moving-off-gpt-image-2-is-sunburst-or-flare-a-drop-in-swap
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-11-12
Last modified: 2026-11-12
Last reviewed: 2026-11-12 (next review due 2026-12-12)
Topic: Agents and multimodal systems
Format: Guide

> No: treat Sunburst and Flare as candidates, not a drop-in. The model id changes, quality gains new values and a new default, edit settings may behave differently, and per-image cost is not a lookup. Run your own paired test before the cutoff.

Key takeaways:
- The names and date in the brief (GPT-Image-2.6, 10 February 2027) were not confirmed on the pages read; verify both on OpenAI's deprecations page before planning.
- The only gpt-image-2 successors named in the sources read are GPT Image 2.5 Sunburst and Flare, and OpenAI's named them for the older gpt-image-1.5 shutdown, not confirmed for gpt-image-2.
- Reference list figures differ sharply per image, but token use varies by model and quality, so measure cost on your own requests.
- Set quality and size explicitly in both arms of the test: the 2.5 default is auto, and xhigh and max exist only on 2.5.
- No latency or prompt-adherence numbers are published here because none were measured; the test plan shows how to produce them.

## What can and cannot be confirmed

The brief for this guide had three claims: gpt-image-2 is deprecated, the cutoff is 10 February 2027, and the successor is called GPT-Image-2.6. None of the three was confirmed on the pages read for this article. OpenAI's pricing page and image guide refused the request. The copy of OpenAI's deprecations page that did load was cut off before the image entries. INFRO's dated timeline of vendor changes, last updated 12 November 2026, lists the gpt-image-1.5 and gpt-image-1-mini shutdown on 1 December and the earlier gpt-image-1 shutdown, with GPT Image 2.5 Sunburst and Flare as OpenAI's recommended replacements [1]. It lists no gpt-image-2 shutdown.

So treat the date as something to check yourself. If it is right, you have 90 days from today. Nothing I could read shows a model called GPT-Image-2.6. The two successors that exist in the sources are **GPT Image 2.5 Sunburst** (`gpt-image-2.5-sunburst`) and **GPT Image 2.5 Flare** (`gpt-image-2.5-flare`) [2][3]. Use those ids only after you confirm on OpenAI's deprecations page which model it names for gpt-image-2.

> **Warning: No side-by-side was run for this article**
> The angle asked for a measured comparison of prompt adherence, per-image cost, latency and size parameters. No such test was run here, so there are no adherence or latency results below. What follows is the confirmed parameter and rate information, the points where a swap is not drop-in, and a harness to produce your own numbers.

## Is it a drop-in swap?

Not by default. A drop-in swap means you change one string and nothing else moves. Four things move.

1. **The id.** Through INFRO the ids are `openai/gpt-image-2`, `openai/gpt-image-2.5-sunburst` and `openai/gpt-image-2.5-flare`; each provider receives the id it expects, such as `gpt-image-2.5-flare` on OpenAI [3].
2. **Quality.** INFRO's image docs list `low`, `medium`, `high` and `auto`, and say GPT Image 2.5 also takes `xhigh` and `max` [4]. The cutover post, relaying OpenAI's guide, says the 2.5 default is `auto`, so a request that omitted quality may render at another setting [5].
3. **Edit settings.** That post also reports OpenAI's guidance to omit `input_fidelity` for gpt-image-2, because every input is processed at high fidelity. Whether the 2.5 models treat a value you already send the same way is not stated on the pages read, so test it [5].
4. **Cost per image.** The reference rates differ, and token use differs by model and quality (next section).

What stays the same on the INFRO side is the request shape: `POST /v1/images/generations` and `/v1/images/edits`, with `n` from 1 to 10, `size`, `resolution`, `aspect_ratio`, `quality`, `response_format` and `seed` [4]. That is a gateway contract, not a guarantee the model behind it renders the same picture from the same prompt.

## What the reference rates say, and why they are not your cost

INFRO's catalog shows OpenAI's list rate per image, checked 2026-10-05: $0.053 for GPT Image 2, $0.013 for Sunburst and $0.013 for Flare [6][2][3]. These are what OpenAI bills on your own account at list; a negotiated rate replaces them, and INFRO adds 0% to model spend.

Read the gap with care. The cutover post reports that Sunburst and Flare are token-priced and share rates, and that OpenAI warns equal token rates do not mean equal cost per image because token use differs by model and quality [5]. A single per-image figure is a reference point for one configuration. Your real cost per image depends on the quality you request, the size and whether you send input images on edits.

> **Example: Illustrative arithmetic, not a measurement**
> Take 100,000 images a month, all rendered at one setting. At the reference figures above that is $5,300 on GPT Image 2 and $1,300 on either 2.5 model. If your measured cost on the 2.5 models at the quality you need came out at three times the reference figure, the second number would be $3,900. Both the volume and the multiplier are invented to show why you measure before you forecast.

Estimate before you send: INFRO's estimates endpoint prices a request per image, with resolution and quality tiers, on your own provider account, and image responses carry the estimated provider cost in `usage.cost` [4]. If you hold negotiated rates, enter them as custom rates so estimates use them before the list rate.

## Size and output parameters to check

Sizes are where "same family" assumptions break quietly. INFRO's image docs say `size` is exact pixels passed to the provider unchanged, and that `resolution` tiers (`512` up to `4K`) and `aspect_ratio` are checked against what the model takes on each target before any call [4]. For OpenAI's GPT Image models, the routing guide reports an exact `WIDTHxHEIGHT` whose edges must be multiples of 16, with neither edge above 3840 pixels and the total between 655,360 and 8,294,400 pixels; resolutions above 2560x1440 are labelled experimental [7].

Do not assume those limits are identical for gpt-image-2 and the 2.5 models; that comparison was not in the pages read. Make it a hard check in the test: for every size your templates use, confirm the returned pixel dimensions equal the requested ones.

| Parameter | What to verify on each candidate |
| --- | --- |
| `size` | Returned width and height equal the request, including your largest print or banner size |
| `quality` | Set explicitly; confirm `high` on gpt-image-2 maps to a quality you accept on 2.5, and decide whether `xhigh` or `max` is worth testing |
| `n` | Count of images returned; a provider may return fewer, and `usage.images` counts what came back [4] |
| Edits | Input-image handling, masks and any `input_fidelity` you send |
| Transparency | Alpha channel actually present where a template needs it |
| `response_format` | `url` is a signed link to a copy stored 24 hours; copy files out or use `b64_json` [4] |

## A paired test you can run this week

Do this while gpt-image-2 still answers: after the cutoff you cannot regenerate the baseline.

1. Pull 30 to 50 real requests per template or feature from your logs, with prompt, size, quality and whether it was an edit. Over-sample the hard cases: text in the image, transparency, edits with references.
2. Run each on all three ids at least three times. The spread between repeat runs of one model is your noise floor; a difference smaller than that is not a difference.
3. Set `quality` and `size` explicitly in every arm.
4. Record status, wall-clock seconds, `usage.cost` and the stored output for every call.
5. Score hard checks automatically, then review a blind sample by humans.

```python
import json, pathlib, time, requests

URL = "https://api.infro.io/v1/images/generations"
HEADERS = {"Authorization": "Bearer " + INFRO_API_KEY}
ARMS = [
    "openai/gpt-image-2",                # baseline, while it answers
    "openai/gpt-image-2.5-sunburst",
    "openai/gpt-image-2.5-flare",
]

def run(case, model, rep):
    body = {"model": model, "prompt": case["prompt"],
            "size": case["size"], "quality": case["quality"], "n": 1}
    t0 = time.time()
    r = requests.post(URL, headers=HEADERS, json=body, timeout=180)
    rec = {"case": case["id"], "model": model, "rep": rep,
           "status": r.status_code, "seconds": round(time.time() - t0, 2),
           "response": r.json()}
    name = f"runs/{case['id']}-{model.replace('/', '_')}-{rep}.json"
    pathlib.Path(name).write_text(json.dumps(rec))
    return rec
```

Use a long timeout. INFRO's docs say expect a few seconds on fast models and up to a minute on the highest-quality ones [4]. Report latency as p50 and p95 per arm at the same quality; comparing a Flare run at `medium` with a Sunburst run at `max` measures your settings, not the models.

For **prompt adherence**, split the checks. Automatable: output dimensions, file format, alpha channel, and OCR of an expected string for templates that print a name or price. Reviewed: layout, brand feel, faces and product shape, by two people blind to the model, or by a model grader you have first calibrated against people. Write the pass bar before you look at results, for example "no more failures than the baseline's own noise floor on hard checks".

## Choosing between Sunburst and Flare

The pages read describe the pair this way: Sunburst is OpenAI's most capable model where editing precision matters most, and Flare is its fastest for high-quality everyday generation [5]. Both show the same $0.013 reference rate in the catalog [2][3], so by list figures the choice is about quality and latency, with measured cost still to be confirmed.

A reasonable default is to split by template. Edit-heavy and reference-image templates go to Sunburst; high-volume generation such as thumbnails goes to Flare; each must pass its own gate. Keep the choice per feature in one mapping table rather than scattered through code, so the next retirement is a config edit.

```python
# feature -> model id. One place to change, one place to test.
IMAGE_MODELS = {
    "product_edit": "openai/gpt-image-2.5-sunburst",
    "social_thumbnail": "openai/gpt-image-2.5-flare",
}
```

## Wiring the cutover with a gateway

If you call OpenAI through INFRO, a few shipped features help here. Model lifecycle records vendor shutdown dates and warns organizations still sending a retiring model, and from the shutdown date refuses it before any provider call, naming the replacement. The console's notices list each deprecated model's retirement date and what in your organization still uses it. These are catalogue-driven, so they depend on the date being recorded; INFRO's timeline did not list a gpt-image-2 date when read, so do not wait for a warning.

Use routing rules to send a slice of one feature to a candidate while the rest stays on the baseline, and compare `usage` cost and latency per request by project and key. A route's failover retries on timeouts and 5xx before the response starts, but treat a fallback image as a new image: seeds are best-effort and not portable across models [4]. For the broader routing picture, see [image model routing](https://infro.io/blog/image-model-routing), and for the earlier wave, the [gpt-image-1.5 cutover checklist](https://infro.io/blog/gpt-image-1-5-and-gpt-image-1-mini-end-dec-1-a-cutover-checklist).

## A dated plan

- [ ] This week: confirm the gpt-image-2 shutdown date and named successor on OpenAI's deprecations page, and record the answer.
- [ ] This week: search code, config, templates, no-code automations and saved presets for `gpt-image-2`, and check 30 days of gateway logs.
- [ ] Within two weeks: freeze baselines on gpt-image-2 with three runs per case, stored outside any expiring URL.
- [ ] Within four weeks: run Sunburst and Flare on the same cases with explicit quality and size, and score them.
- [ ] Then: canary 5 to 10 percent of one feature, compare measured cost per image against your forecast, and widen only if the gate holds.
- [ ] Leave at least two weeks before the cutoff for rollback and for customers who stored a model choice.

## Questions

### Should I move straight to Flare because it is described as faster?

Only if your acceptance gate passes on it. OpenAI describes Flare as its fastest model for high-quality everyday generation and Sunburst as the most capable for editing precision [5]. Route editing-heavy templates to Sunburst and everyday generation to Flare in the test, then keep whichever passes.

### Do I need to change my code if I call through a gateway with a mapping layer?

If the model id lives in one mapping table, the id change is a config edit. The settings still need review: quality values and defaults, edit fidelity and size choices are request-level changes, not id changes.

## Sources

1. AI model updates: releases, price changes and shutdowns — INFRO. https://infro.io/ai-updates (accessed 2026-11-12)
2. GPT Image 2.5 Sunburst API pricing — INFRO model catalog. https://infro.io/models/openai/gpt-image-2.5-sunburst (accessed 2026-11-12)
3. GPT Image 2.5 Flare API pricing — INFRO model catalog. https://infro.io/models/openai/gpt-image-2.5-flare (accessed 2026-11-12)
4. Image generation — Modalities — INFRO Docs. https://infro.io/docs/modalities/images (accessed 2026-11-12)
5. gpt-image-1.5 and gpt-image-1-mini end Dec 1: a cutover checklist — INFRO. https://infro.io/blog/gpt-image-1-5-and-gpt-image-1-mini-end-dec-1-a-cutover-checklist (accessed 2026-11-12)
6. GPT Image 2 API pricing — INFRO model catalog. https://infro.io/models/openai/gpt-image-2 (accessed 2026-11-12)
7. Image router: routing image generation across providers — INFRO. https://infro.io/blog/image-model-routing (accessed 2026-11-12)
