A rate of $30 per million output tokens sounds cheap until you need to budget 10,000 images. ChatGPT Images 2.5 API pricing is identical for Flare and Sunburst, but the final bill depends on tokens consumed, reference inputs, edits, and retries—not the model name alone.
These are planning scenarios, not fixed quotes; OpenAI does not publish one universal price per GPT-Image-2.5 image.
The rate card—and the number it does not tell you
OpenAI charges both GPT-Image-2.5 API models at the same token rates. The official price sheet lists gpt-image-2.5-flare and gpt-image-2.5-sunburst at $30 per million image-output tokens, with separate charges for prompt text and image inputs.
Official GPT-Image-2.5 token rates
| Billed data | Standard input | Cached input | Output |
|---|---|---|---|
| Text tokens | $5.00 / 1M | $1.25 / 1M | Not applicable |
| Image tokens | $8.00 / 1M | $2.00 / 1M | $30.00 / 1M |
Source: OpenAI API pricing, checked September 9, 2026.
OpenAI positions Flare as the default for most applications and high-volume generation. Sunburst is the slower, precision-oriented option for controlled edits and production-ready creative. OpenAI says Flare offers up to 50% lower latency than GPT-Image-2, while Sunburst takes longer to generate.
The list price does not establish a fixed image price. A request that produces 2,000 output tokens costs one-tenth as much as a request producing 20,000 output tokens, before inputs and retries.
Cost formula for generation and editing
Use this formula for a direct image API call:
cost =
(text_input_tokens × $5 / 1,000,000)
+ (cached_text_tokens × $1.25 / 1,000,000)
+ (image_input_tokens × $8 / 1,000,000)
+ (cached_image_tokens × $2 / 1,000,000)
+ (image_output_tokens × $30 / 1,000,000)
For text-to-image generation without a reference image, output tokens will usually dominate the arithmetic. A 500-token prompt costs $0.0025; 7,000 image-output tokens cost $0.21.
Editing adds image-input charges because the source or reference image must be processed. Multi-turn workflows can also produce a new bill on every call, so the meaningful production metric is cost per approved asset rather than cost per first attempt.
Per-image cost examples from token usage
The only defensible per-image calculation starts with the usage recorded for a completed request. The following examples deliberately use round token counts so that you can replace them with values from your own API logs.
Output-only generation examples
Assume each request has 500 uncached text-input tokens and no input image.
| Planning scenario | Image-output tokens | Text cost | Image-output cost | Total per call | 1,000 calls |
|---|---|---|---|---|---|
| Lean output | 2,000 | $0.0025 | $0.0600 | $0.0625 | $62.50 |
| Midrange output | 7,000 | $0.0025 | $0.2100 | $0.2125 | $212.50 |
| Heavy output | 20,000 | $0.0025 | $0.6000 | $0.6025 | $602.50 |
These are token-to-dollar conversions, not claims that a named quality setting always consumes a particular number of tokens. Replace the round figures with billed usage from your own calls.
The table also shows why shortening an already modest prompt rarely transforms the budget. Cutting a 500-token prompt in half saves $0.00125, whereas reducing output from 20,000 to 7,000 tokens saves $0.39 per call.
Reference-image and edit examples
Assume an edit uses 500 text tokens, 5,000 image-input tokens, and 7,000 image-output tokens.
| Component | Tokens | Rate | Cost |
|---|---|---|---|
| Text instruction | 500 | $5 / 1M | $0.0025 |
| Reference image | 5,000 | $8 / 1M | $0.0400 |
| Edited output | 7,000 | $30 / 1M | $0.2100 |
| Total | — | — | $0.2525 |
If the same image input qualifies for cached pricing, its 5,000-token input charge falls from $0.04 to $0.01. The hypothetical call then costs $0.2225.
Three edit calls with the same uncached token profile cost $0.7575. If only the third result is approved, the effective API cost is $0.7575 per usable asset—not $0.2525.
Flare versus Sunburst budgeting
Flare and Sunburst have identical published token rates, so neither model is automatically cheaper per call. Flare is the safer default for a budget because OpenAI designed it for speed and volume; Sunburst should earn its place by reducing failed precision edits or manual cleanup.
A launch-day concern from developers is that equal rates do not answer the real budgeting question:
“I wish Flare's pricing was juuuust a little bit cheaper.” — @buildincrisis on X
Because both models share unit rates, savings must come from lower token use, fewer retries, faster capacity turnover, or smarter routing.
A 10,000-call monthly budget
Consider a planning model with these assumptions:
- Flare call: 7,000 output tokens plus 500 text tokens = $0.2125
- Sunburst call: 20,000 output tokens plus 500 text tokens = $0.6025
- No reference-image charges, caching, or failed calls
| Routing plan | Flare calls | Sunburst calls | Estimated monthly API cost |
|---|---|---|---|
| Flare only | 10,000 | 0 | $2,125 |
| 90% Flare / 10% Sunburst | 9,000 | 1,000 | $2,515 |
| 70% Flare / 30% Sunburst | 7,000 | 3,000 | $3,295 |
| Sunburst only | 0 | 10,000 | $6,025 |
The difference comes from the assumed token use, not different provider rates. Substitute measured median tokens per model and workload before approving a production budget.
Budget per usable image, not per API call
Suppose a Flare workflow costs $0.2125 per attempt and 80% of calls produce an acceptable image. The effective API cost is approximately $0.266 per usable image:
$0.2125 ÷ 0.80 = $0.265625
If Sunburst costs $0.6025 per attempt but achieves a 95% acceptance rate on precision edits, its effective cost is about $0.634 per usable image. Sunburst still costs more in that example, but the gap may be justified when manual retouching costs several dollars or a failed brand edit blocks publication.
Real-user discussion already reflects this broader cost problem. In a launch thread, Reddit user u/EvenAd2969 wrote, “They need to get rid of these noisy artifacts.” (source) Artifacts are not merely a quality complaint: every regeneration increases spend and delays approval.
Keep ChatGPT Images 2.5 spend predictable
Predictable spending comes from measuring each workload separately. Do not set one global “cost per image” for generation, reference-led transformation, and multi-turn editing.
- Keep request settings constant during measurement. A stable configuration produces a cleaner baseline for comparing jobs.
- Log billed text input, image input, cached input, and image output. Calculate median and 90th-percentile cost; the average can hide expensive outliers.
- Cap attempts per asset. A three-attempt ceiling prevents a problematic prompt from silently multiplying the bill.
- Route by failure cost. Start creator content, thumbnails, visual search, and prototypes on Flare. Send product preservation, campaign edits, and approved-asset revisions to Sunburst.
- Recalculate using acceptance rate. A nominally cheap model can be expensive if the team rejects half its results.
OpenAI’s announcement reports that Manus observed Flare running two to four times as fast as GPT-Image-2 in its evaluation. That customer report concerns speed, not a guaranteed reduction in billed tokens or dollars.
What ChatGPT subscriptions do—and do not—cover
ChatGPT plan access and API billing are separate products. OpenAI says ChatGPT Images 2.5 is available across ChatGPT, ChatGPT Work, and Codex, but ChatGPT and the API use separate billing systems. A ChatGPT Plus, Pro, or Work payment is not prepaid GPT-Image-2.5 API credit; direct API calls are billed to the API account.
A routing decision you can put into production
The most defensible default is Flare first, Sunburst by exception. Use measured cost per accepted image to decide whether an exception should become a permanent route.
| Workload | Starting model | Budget reason |
|---|---|---|
| Social variants and thumbnails | Flare | Speed and high-volume positioning |
| Product discovery or visual search | Flare | Interactive latency matters |
| Early concepts and A/B creative | Flare | Many outputs will be discarded by design |
| Final campaign image | Sunburst | Precision can outweigh call cost |
| Edit that must preserve a product or person | Sunburst | Use only if an acceptance-rate test reduces retries or retouching |
| Unclassified request | Flare | OpenAI names it the default for most applications |
A practical escalation rule is simple: try Flare once, then send the job to Sunburst when the first result fails a documented preservation or precision check. Do not escalate merely because Sunburst is labeled premium.
ChatGPT Images 2.5 API pricing FAQ
Is Flare cheaper than Sunburst?
No at the published unit-rate level. Both models cost $5 per million text-input tokens, $8 per million image-input tokens, and $30 per million image-output tokens; actual call cost can differ if token consumption differs.
How much does one GPT-Image-2.5 image cost?
There is no universal fixed price. At the official $30-per-million output rate, 2,000 image-output tokens cost $0.06, 7,000 cost $0.21, and 20,000 cost $0.60, before text and image inputs.
Do edits cost more than fresh generations?
Edits can cost more because they add image-input tokens and may require multiple calls. Cached image-input pricing can reduce repeated-input charges from $8 to $2 per million tokens when applicable.
Does prompt text materially affect the bill?
Usually less than image output. A 500-token uncached prompt costs $0.0025, while 7,000 image-output tokens cost $0.21 at the current standard rates.
Is the API included with ChatGPT Plus or Pro?
No. ChatGPT subscriptions govern access and limits inside ChatGPT; direct GPT-Image-2.5 API usage is billed separately through the API account.
Related reading: ChatGPT Images 2.5 review and tests · GPT Image 2 API pricing