GPT Image 2.6 held the token price and raised the bill

OpenAI shipped GPT Image 2.6 on 4 November 2026, as two models on the Images API. Eleven days later the pair together was handling about 29 percent of the request volume of the pair it replaces. The first fact is a launch note. The second is being read in a few places as a verdict, and it should not be.
What shipped on 4 November
gpt-image-2.6-flare is positioned for fast iteration and everyday image work. gpt-image-2.6-sunburst is positioned for detailed visual work, precision and consistency across edits at medium or high quality. Both succeed GPT Image 2.5, which arrived in September 2026.
The feature list runs long. Markup-guided editing lets you overlay a transparent PNG marking the region you want changed, describe the change, and get back a result with the annotation removed. The removal is the useful half. Describing a region in words is where edits usually go wrong, and a mask that comes back clean means one less pass to scrub a stray outline out of the corner.
SVG output on the generations endpoint, n=1. Animated GIF output on generations or edits, frame_count from 2 to 16, frame_duration_ms from 20 to 2000. GIF creation also turned up inside ChatGPT that week.
Then the one that matters for money: a complexity control. Low, medium or high, default high, described as how much planning happens before rendering. No separate fee. Higher settings can increase latency.
The rates did not move
Both 2.6 models carry token rates identical to 2.5: $5 per million text input tokens, $1.25 for cached text input, $8 per million image input, $2 for cached image input, $30 per million image output.
On a rate card, that reads as a free upgrade. New capabilities, same prices, plus a speed claim. OpenAI says 2.6 generates about 50 percent faster than before, and has not published the baseline, so the claim cannot be checked directly. Early testers reported 6.7 to 8.9 seconds for a 1024x1024 image at medium quality, against about 12 seconds on 2.5. At 8.9 seconds that is a modest win. At 6.7 it is nearly double, and the spread is the honest part of an unpublished baseline.
The invoice tracks token count, not seconds.
Where the bill actually moves
Cost per 1024x1024 image, measured from returned usage:
| Quality | Cost per image |
|---|---|
| Low | $0.025 |
| Medium | $0.043 |
| High | $0.053 |
| Xhigh | $0.094 |
| Max | $0.21 |
One published test of a medium-quality Sunburst generation used 109 text input tokens and 1,449 image output tokens, which works out to about $0.044. That lands close enough to the table to trust the arithmetic rather than take it on faith.
The wrinkle sits at the cheap end. A flat rate per token only produces a flat rate per image if the image consumes the same number of tokens, and on 2.6 it does not. At low and medium quality, 2.6 uses more output tokens than 2.5 did. One analysis put the low-quality tier at roughly 4.2 times the old token count. That multiplier is one analysis, not a figure OpenAI published, and I would hold it loosely. The direction is what I trust: drafted at low quality, the new model does more work than its predecessor, and nothing on the rate card says so.
Low quality is also where volume lives. Someone generating a hero image a week will not notice $0.018. Someone generating a thousand thumbnails before lunch will, and that is the customer an unchanged rate card is best at reassuring.
The complexity knob tilts it a little further. It costs nothing, it defaults to high, and high means more planning before rendering. So the default configuration is the slow one, and if planning spends tokens, the costly one. Reaching the cheaper path takes knowing the setting exists and deciding to turn it down. Defaults set prices. Almost nobody files them under pricing.
Two names, one price, two costs
Flare and Sunburst cost the same per token. They do not cost the same per image.
Sunburst is built for precision and consistency across edits, which means more scene detail and more tokens spent describing it. Flare is built for iteration, which usually means generating candidates and throwing most of them away. Same rates, different burn. The price sheet hands you one number for both and no way to tell which name a given prompt will come out cheaper on. Two names at one price is one way to ship a speed tier without shipping a price tier, and it moves the decision onto users who mostly will not measure it.
I do not think that is a scheme. When the difference between two variants is latency and edit fidelity rather than cost, naming them apart is a fair product call. The side effect is that you pick a variant by reputation, pick a quality tier by feel, leave complexity at the default, and the invoice arrives with no line item that explains itself.
What the 29 percent can and cannot say
The volume numbers come from OpenRouter's public image leaderboard for 14 November 2026. One day, image_output_requests, parsed from the page:
| Model | Requests |
|---|---|
| gpt-image-2.5-sunburst | 1,185,863 |
| gpt-image-2.5-flare | 893,853 |
| gpt-image-2.6-sunburst | 374,843 |
| gpt-image-2.6-flare | 230,996 |
2.5's pair totals 2,079,716. 2.6's pair totals 605,839. That is 29 percent, and the obvious reading is a soft launch.
The obvious reading ignores the calendar. 2.5 had roughly two months for third-party tools to integrate it, for wrapper libraries to add it, for defaults to be re-pointed at it. 2.6 had eleven days. Weighing an eleven-day integration footprint against a two-month one measures distribution, not preference. A model can be faster, better at edits and priced identically per token and still sit at 29 percent on day eleven, because the software that calls it has not been updated yet.
For scale: the top image model that day was google/gemini-3.1-flash-image at 2,345,139 requests. The top 20 together accounted for 10,873,674.
Two boundaries on the figure itself. It counts requests that returned an image, on one aggregator, on one day. Aggregator traffic skews toward developers testing a model rather than production pipelines running one, so if low-quality draft volume sits in production and production bills first-party, this leaderboard is watching the wrong room. It is a real measurement of a narrow thing.
The number to watch
The 29 percent will drift upward on integration alone and say little either way. The per-token rate did not move and is not going to. The figure worth tracking is output tokens per image at low and medium quality, read off returned usage, checked a month from now once 2.6 has had the integration window 2.5 got. If it holds near where the early measurements put it, 2.6 is a price increase wearing an unchanged rate card, and the speed gain gets partly repaid in retries and upscales. If it drops in a minor point release, the rate card was never the interesting document.
One date to keep in view alongside it: 1 December 2026, when OpenAI removes gpt-image-1-mini, gpt-image-1.5 and chatgpt-image-latest from the API. Everyone still running those has to move somewhere, and 2.6 is the nearest door. Whether the 2.5 pair holds its volume through that migration, or hands a chunk of it to the new models in a single week, will say more about adoption than any eleven-day snapshot can.
Related articles
Chinese text in video always turns to mush. Dreamina handed the typesetting to code
Dreamina launched Motion Studio on November 10. It no longer generates frames; the model writes code that lays out text, shapes and pacing. Chinese titles stop blurring, but whether the content is right is still on you.
A community spreadsheet of taps that turns off the ads inside Chinese Android builds
A no-root tool that switches off the ads Chinese phone makers ship inside the system UI. Its method is a hand-written tap script per phone model, maintained by volunteers every time a ROM moves. It works, and the maintenance is the point.
Someone rebuilt IDM from the outside and wrote down what they did not touch
A Rust reimplementation of Internet Download Manager claims 5x the speed and 86 languages. The more interesting document is the paragraph explaining how it was built without copying anything.
Rune is a Rust UI framework built so an agent can check its own work
Rune renders headless, dumps its element tree and takes scripted input, which gives a coding agent something a screenshot never could, a diffable signal. The framework is pre-release and takes no pull requests.