GPT Image 2.6 Pricing 2026: Real Cost Per Image Explained
GPT Image 2.6 does not charge a fixed price per image. Both 2.6 models, Flare and Sunburst, bill by token at identical rates: $5 per million text input tokens, $8 per million image input tokens, and $30 per million image output tokens. For a 1024×1024 image, third-party estimates range from about $0.006 to $0.21 depending on quality, and the sources do not fully agree.
If different websites quote you different prices, there is a reason. One widely copied estimate puts a high-quality image at $0.211, while a single-sample measurement in an API provider's documentation puts its high tier at $0.053. This guide compares OpenAI's published token rates with third-party estimates and measurements, explains why the numbers differ, and shows how to calculate your own costs from API usage data. For a feature overview, see our GPT Image 2.6 overview, covering GIF generation, SVG export, and speed claims.
This guide uses OpenAI's API pricing page, model documentation, and third-party estimates and measurements checked on November 5, 2026. Per-image figures are estimates or individual measurements, not official prices. Your actual API usage determines your bill.
How GPT Image 2.6 Pricing Works
Every request pays for up to four token types:
Text input: your prompt, at $5 per 1M tokens.
Image input: reference images or images being edited, at $8 per 1M tokens.
Image output: the generated image, at $30 per 1M tokens. This line is most of the bill.
Cached input, when a request qualifies: $1.25 per 1M for text, $2 per 1M for images.
Five things that change the bill and rarely show up in the sticker rates:
Flare and Sunburst cost the same. OpenAI positions Flare for speed (the official claim is 50% faster than 2.5) and Sunburst for detail and edit consistency. Picking one saves no rate, only rework. Our Flare vs Sunburst comparison covers the split.
Quality and complexity are separate dials. quality drives token cost. complexity (default high) controls how much the model plans before rendering, carries no fee, and makes it more likely to change things you did not ask for. That is rework cost the bill never itemizes.
GIFs bill as one sheet, not per frame. You set output_format to gif, plus frame_count (default 9). OpenAI has published no per-frame price; one API provider measured a 9-frame low-quality 512x512 GIF at about 1,172 output tokens, roughly $0.035. GIFs only work on the generations endpoint.
Streaming previews cost extra. partial_images adds 100 output tokens, about $0.003, per partial frame. It is $3 across a 1,000-image month.
Batch half-price is a 2.5 feature, and the 2.6 picture is disputed: one write-up says the pricing page lists Batch rates for 2.6, while two say the model pages mark Batch as not supported. Do not build Batch savings into a 2.6 budget.
GPT Image 2.6's published pricing includes cached input rates, but actual cache hits depend on the request method and Prompt Caching eligibility. Reusing a reference image does not guarantee the discounted rate.
The Only Cost Table You Need
OpenAI publishes token rates and a cost calculator, not a per-image price list, so every per-image figure out there is somebody's estimate or measurement. Here are the two main sets, disagreement included:
| Quality (1024x1024) | Estimate table (AIHubMix) | Measured tokens (reAPI, one sample per cell), converted at $30/1M | What the gap means |
|---|---|---|---|
| low | $0.006 | 824 tokens, about $0.025 | A 4x gap; apidog independently reports the same rise |
| medium | $0.053 | 1,449 tokens, about $0.043 | Same order of magnitude, about 20% apart |
| high | $0.211 | 1,758 tokens, about $0.053 | The measured "high" equals the estimated "medium" |
| xhigh / max | Not listed; the safe set for 2.6 is low, medium, high, auto | 3,122 tokens, $0.094; 7,024 tokens, $0.211 | The measured "max" equals the estimated "high"; OpenAI has not confirmed these tiers for 2.6 |
| 1024x1536 or 1536x1024 | $0.005 / $0.041 / $0.165 (low / medium / high) | low measured 664 tokens | Not a simple ladder; unconfirmed for 2.6 |
Per-image values are third-party estimates or single-sample measurements, not official prices. The only official per-request truth is the usage field in the API response. Multiply output_tokens by $30 per million to calculate image output cost. For the full request cost, also include text and image input tokens at their respective rates, applying cached input rates only when eligible.
Two anchors keep the rest of this page consistent: a common tier of $0.053 per image (estimated medium, measured high) and a top tier of $0.211 (estimated high, measured max). The low tier stays a range, $0.006 to $0.025, because that is where the sources genuinely disagree.
Inputs are the same at every tier: text at $5/1M, images at $8/1M. One 1024x1024 reference image measured about 1,024 image input tokens, call it +$0.008 per edit round. That is why our prompt library for the 2.5 generation keeps instructions tight.
What Your Month Will Cost: Three Scenarios
The arithmetic works across the whole 2.x family since the rates are shared; our GPT Image 2 baseline has the capability context. The formula:
Monthly cost ≈ (generation attempts × output cost)
+ (edit rounds × (output cost + reference image input cost))
Cost per usable image = total monthly cost ÷ accepted imagesEvery calculation below is plain arithmetic from the two anchor prices, with assumptions stated; these are worked examples, not benchmarks we ran. These scenarios simplify the calculation by focusing on image output and reference image input costs. Text prompt input costs are excluded, so actual API bills may be slightly higher.
Scenario A, light use: 10 usable images at the common tier, 1.5 attempts each, is 15 x $0.053 = $0.80 for the month, or $3.17 all at the top tier. At this volume no subscription pays for itself on image spending alone.
Scenario B, batch work: 200 usable images with 80% first-pass acceptance, an assumption, not a law of nature. Accepting 4 out of 5 means 250 attempts: $13.25 at the common tier, $52.75 at the top tier. Count your acceptance rate before you count money. Note that $13.25 of API spend sits under a $20 Plus subscription on paper, but the two are not equivalent services; the comparison section handles this.
Scenario C, iterative editing: 30 final images, each one generation plus 3 edit rounds with a reference image attached. Top tier: 30 x $0.211 = $6.33 to generate, then 90 x ($0.211 + $0.008) = $19.71 to edit. Total $26.04, and 76% of it went to edit rounds. Common tier: 30 x $0.053 + 90 x $0.061 = $7.08, and edits are still 78% of it. The bill's biggest lever is how many rounds you run, not the model tier.
Plug in your own numbers: target 40 usable images, 1.5 attempts per image (60 attempts), 20 needing 2 edit rounds (40 rounds), one reference image per round, common tier:
60 × $0.053 + 40 × ($0.053 + $0.008)
= $3.18 + $2.44
= $5.62
Cost per usable image = $5.62 ÷ 40 = $0.14Top tier, same steps: $21.42, or $0.54 per usable image. Swap in your own numbers, then read the exact per-image price off usage.output_tokens as shown below.
Why Your Bill Is Higher Than Expected
The concept behind most surprise invoices: cost per usable image. The sticker price assumes every generation is a keeper. It is not.
At the common tier, 80% acceptance turns $0.053 into $0.066 per keeper, 60% into $0.088, three attempts into $0.16, triple the sticker. The top tier scales the same way: $0.264, then $0.352, then $0.633. You cannot change the per-token rates. You can change how many images you throw away before one passes.
| What you see | What is actually happening | The fix |
|---|---|---|
| Bill runs 1.5x to 3x the sticker math | Reruns; every retry pays full price | Compute your acceptance rate; fix prompts, not reruns |
| Each image costs a few cents more than quoted | Input tokens from prompts and reference images at $8/1M | Tighten prompts; check cached rates |
| Small odd amounts on the invoice | partial_images previews, +$0.003 each | Turn streaming off if nobody watches |
| GIF requests cost far more than stills | A GIF bills as one frame sheet | Run one, read usage.output_tokens, extrapolate |
| Batch savings never showed up | 2.6 Batch support is disputed | Budget Batch discounts on 2.5 only |
| The auto tier bill swings month to month | auto bills on whatever the model generates | Pin a fixed tier on budget-sensitive jobs |
| Your numbers match no published table | 2.6's low tier measures around 4x one estimate table | Trust your own usage tokens over every table |
When generations fail outright rather than just disappoint, our GPT Image generator troubleshooting guide handles the failure side of the same coin.
How to Compare GPT Image 2.5 vs 2.6 Costs
Nobody has published a clean same-task comparison of the two generations, and we have not run one either. What exists is one measured sample (824 output tokens, low-tier square) and one apidog claim that 2.6's low tier rose about 4x while higher tiers stayed flat. Neither ran both models on the same prompt. If you have API access, this protocol settles it in an afternoon:
One fixed prompt, for example: "A ceramic mug with a blue leaf pattern on a pale wood table, soft window light from the left." size 1024x1024, n=1, streaming off.
Two models (gpt-image-2.5-sunburst and gpt-image-2.6-sunburst) across quality levels low, medium, high, 3 runs per cell, 18 calls total; expand to 5 per cell only if the numbers are noisy. Record per call: usage.output_tokens (the core number), usage.input_tokens, wall time, and whether the image passed your acceptance check.
What to compare: same-tier token drift (where a real 4x low-tier jump would show up), same-tier acceptance rate (cheaper tokens mean nothing if you rerun twice as often), and wall time (OpenAI's 50% faster claim is a claim, not a stopwatch).
Verdict math: image output cost = median output_tokens × $30/1M. For full request cost, also include text and image input tokens at their respective rates. Drop the resulting cost into the scenario formula in place of the anchor prices.
No API access? Inside ChatGPT you cannot read token counts, so the same exercise degrades to same-prompt side-by-sides with an acceptance tally. That compares quality and rerun counts, not cost.
GPT Image 2.6: API vs ChatGPT Subscription
One warning: GPT Image 2.6 pricing on the API and a ChatGPT subscription are not two prices for the same product. The API is usage-based and automatable, with costs determined by token consumption and subject to API rate limits. A subscription bundles image generation with conversation, projects, and Codex under limits OpenAI does not publish as image counts. The honest question is not "which one is cheaper per image" but "what does an equivalent API budget buy, and what else does each side give you."
The table divides each plan's monthly fee by the two anchor prices. These figures compare subscription spending with an equivalent API budget, not images included in a ChatGPT subscription; Shared Plus limits vary by usage, so actual capacity cannot be calculated from price alone.
| Path | Monthly fee | API-equivalent images at $0.053 | At $0.211 | The catch |
|---|---|---|---|---|
| API, pay as you go | From $0 | - | - | You write the code and watch the budget |
| ChatGPT Plus, official | $20 | 377 | 95 | Image limits exist, but OpenAI publishes no fixed count |
| ChatGPT Pro, official | $200 | 3,774 | 948 | You are buying capacity, not a cheaper rate |
| FamilyPro Shared Plus | $5.50 | 104 | 26 | Chat history and quota shared with up to 4 people; no Codex |
| FamilyPro private account | $18 | 340 | 85 | Independent account, $2 under official, delivered through a third party |
| FamilyPro top-up on your own account | $23.19 | 438 | 110 | More expensive than official $20; you are paying for payment access, not a discount |
Who each row actually fits:
API: developers, automation, GIF and SVG pipelines. If you only ever click buttons in the ChatGPT web UI, this is the wrong tool.
Official Plus at $20: people who will genuinely use conversation, projects, and Codex alongside images. If you would pay $20 purely to generate images while your monthly API spend computes below $20, the subscription is not paying for itself. That covers image spending only; Plus's other features carry value this article does not price. Our Plus vs Pro breakdown covers the upper tiers.
Official Pro at $200: teams producing hundreds of images a day. For an individual doing a few hundred a month, it is badly oversized.
FamilyPro Shared Plus at $5.50: fits a budget-sensitive individual whose work happens in the ChatGPT web UI and who does not need private history, Codex, or guaranteed peak capacity. If any of those apply, this is the wrong row. Our guide on how shared ChatGPT accounts work walks through the trade-offs. FamilyPro also lists a private account at $18 for people who want isolation and accept third-party delivery; the $2 saving over official is thin, and buying direct is steadier if your card works.
FamilyPro top-up at $23.19: this one costs more than official Plus, and we say so plainly. It exists for one situation: your cards get declined by OpenAI's checkout or your region is unsupported and you need a working payment path onto your own account. If you can pay OpenAI directly, skip it.
Tying this back: Scenario A's under-$4 month justifies no subscription. Scenario B's $13.25 at the common tier can fit inside a Plus budget if the product limits hold up; $52.75 at the top tier points back to the API or a mix of both. Scenario C's editing favors a subscription only if the web limits cover your round count.
Cutting the Bill Without Cutting Quality
Four moves, each with a number attached. The arithmetic is theoretical conversion from the anchors above, not benchmarks we ran.
Draft cheap, finish expensive. 40 low-tier drafts on Flare plus 4 top-tier finals on Sunburst: on the estimate table that is 40 x $0.006 + 4 x $0.211 = $1.08; on the measured tokens it is 40 x $0.025 + $0.844 = $1.84. The same 44 images all at the top tier would cost $9.28. Savings land between 80% and 88% depending on which low-tier caliber is right, which is what the protocol above is for.
Say the whole edit in one round. Scenario C at 3 rounds spends $19.71 on edits at the top tier; cutting to 2 rounds across 30 finals saves 30 x $0.219 = $6.57. The mechanic: list what changes and what must stay identical in the same message. "Replace the table surface with stone. Preserve the mug shape, handle, leaf pattern, camera angle, and light direction" beats three rounds of "now change X."
Turn streaming off when nobody is watching. 1,000 partial previews a month cost $3. Small money, zero effort.
Cache hits on repeated reference images: the cached rate is $2/1M against $8/1M, so if all 90 of Scenario C's edit rounds hit cache the theory saves about $0.55. GPT Image 2.6's published pricing includes cached input rates, but actual cache hits depend on the request method and Prompt Caching eligibility. Treat the savings as conditional, not guaranteed.
GPT Image 2.6 Pricing FAQ
How Is GPT Image 2.6 Billed?
By token, not per image: text input, image input, image output (the dominant line at $30 per 1M tokens), and cached input where it applies. To price your own usage, read usage.output_tokens from an API response and multiply by the output rate.
Is GPT Image 2.6 Included in ChatGPT Plus?
Yes. OpenAI states Images 2.6 is available in ChatGPT across all subscription tiers. But OpenAI publishes no fixed image count for any plan, and the API is a separate bill that does not share quota with a subscription.
Why Is My Bill Higher Than the Per-Image Price I Saw?
Four usual suspects: reruns (every retry pays full output price), input tokens from long prompts and reference images, streaming previews, and GIFs billed as whole frame sheets. The diagnosis table above maps each to a fix.
Is GPT Image 2.6 More Expensive Than 2.5?
The token rates are identical. The open question is consumption: two third-party sources report 2.6's low tier burning roughly 4x the output tokens the most-copied estimate table assumes, higher tiers unchanged. Neither ran a same-task comparison; the protocol above settles it in about 18 calls.
Do I Need a Subscription or the API?
If your month is a handful of images, neither: metered API spend stays under a coffee, and ChatGPT's free tier may cover the rest. Past that, web UI work points at a subscription; automation, GIF batches, and SVG pipelines point at the API, since only it supports them. If your image-only API spend computes below your plan's fee, the subscription is not paying for itself on images.
GPT Image 2.6 pricing will keep moving for a few weeks: Batch support is still disputed, and the per-image tables will get rewritten as real invoices accumulate. The usage field in your own API response is the one price that never goes stale.