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) 23. Use those ids only after you confirm on OpenAI's deprecations page which model it names for gpt-image-2.
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.
- The id. Through INFRO the ids are
openai/gpt-image-2,openai/gpt-image-2.5-sunburstandopenai/gpt-image-2.5-flare; each provider receives the id it expects, such asgpt-image-2.5-flareon OpenAI 3. - Quality. INFRO's image docs list
low,medium,highandauto, and say GPT Image 2.5 also takesxhighandmax4. The cutover post, relaying OpenAI's guide, says the 2.5 default isauto, so a request that omitted quality may render at another setting 5. - Edit settings. That post also reports OpenAI's guidance to omit
input_fidelityfor 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. - 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 623. 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.
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.
- 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.
- 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.
- Set
qualityandsizeexplicitly in every arm. - Record status, wall-clock seconds,
usage.costand the stored output for every call. - Score hard checks automatically, then review a blind sample by humans.
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 recUse 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 23, 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.
# 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, and for the earlier wave, the gpt-image-1.5 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.
