Budgeting GPT-Image-2.5 Around Accepted Images, Not Requests

The number I would actually optimize

I would not put a single “GPT-Image-2.5 price per image” into a production budget. The API bills tokens, and an image that gets rejected still costs money.

My primary metric would be:

Cost per accepted asset = total generation and editing spend ÷ accepted assets

For example, the observed output-token estimate for a high-quality 1024×1024 image is $0.05268. Ten generations would cost $0.5268 in output tokens. If only six make it through review, that becomes $0.0878 per accepted asset, before input costs.

That distinction matters more than the choice between Flare and Sunburst: both have the same official token rates. A slower model can be cheaper operationally if it avoids failed edits and repeated generations.

There are three separate questions to answer:

• What does each token category cost?
• How many tokens does the chosen quality setting consume?
• How many attempts does the workflow need to produce something usable?

Only the first has a straightforward price card.

Start with the billing categories

The official Flare documentation lists these rates, shared by Sunburst:

For uncached usage:

Request cost = (text-input tokens × $5 + image-input tokens × $8 + image-output tokens × $30) ÷ 1,000,000

Use the cached rates for eligible cached inputs rather than charging those tokens at the standard rate.

A generation with 120 text-input tokens and 1,756 image-output tokens costs:

• Text input: $0.0006
• Image output: $0.05268
• Total: $0.05328, with no image-input charge

Short prompts generally contribute little relative to image output. Editing is different: multiple reference images introduce image-input usage, so I would not apply a text-to-image estimate to a reference-heavy editing pipeline.

ChatGPT subscriptions do not include API credits. Developer API usage is billed separately to the API account.

Treat per-image estimates as a planning model

The Flare and Sunburst documentation explicitly says the GPT Image 2 calculator does not estimate GPT Image 2.5 token consumption.

Separately, APIdog recorded a shared GPT Image 2.5 calculator entry on September 9, 2026. Its observed token budgets provide a useful starting point, but they are not guaranteed official per-image prices.

At $30 per million image-output tokens:

These estimates exclude prompts, reference images, retries, variations, and subsequent editing passes.

The wording I would use in a budget is: “Approximately $0.053 in output cost for a high-quality square generation under the observed token estimate.” Calling that the total request price would hide too many assumptions.

The migration trap: high changed meaning

GPT Image 2 high was around $0.211 for a 1024×1024 image. GPT-Image-2.5 high is approximately $0.05268 in the observed estimates.

That looks like a fourfold reduction, but the quality ladder changed:

These are token-budget equivalents, not claims of identical visual quality.

If I were migrating a pipeline, I would test high rather than blindly preserve the label. If the requirement were to retain approximately the old high token budget, max would be the closer setting.

Choose the model by failure mode

OpenAI announced ChatGPT Images 2.5 on September 8, 2026. The release emphasizes sharper detail, more natural lighting and textures, better reference-subject preservation, more reliable multi-turn editing, and lower latency.

OpenAI positions Flare as the default for most applications, reporting higher image quality than GPT Image 2 and up to 50% lower generation latency. Sunburst prioritizes precision generation and editing and can take longer.

Both variants support:

• Quality settings: low, medium, high, xhigh, max, auto
• Recommended dimensions: 1024×1024, 1536×1024, and 1024×1536
• Transparent output in PNG or WebP

Function calling, structured outputs, and fine-tuning are not part of this image-model interface. For deployment predictability, I would consider pinning a dated snapshot instead of relying solely on the moving model ID.

My default routing would be Flare for generation volume and exploration. I would evaluate Sunburst when preserving a product, subject, or composition matters more than minimum latency.

There is no Sunburst surcharge per token. If it delivers an acceptable campaign asset in one attempt where Flare needs two or three retries, the higher-precision route may have the lower effective cost.

Read the evaluations without mixing metrics

The Arena leaderboard results cited for this release put both variants ahead of GPT Image 2 in text-to-image generation and single-image editing. The GPT-Image-2.5 results are marked preliminary.

These are third-party human-preference scores, not OpenAI-controlled quality benchmarks. Sunburst’s roughly 29-point lead over Flare on single-image editing is consistent with its precision-oriented positioning, but I would still test it against the assets my application actually handles.

OpenAI’s safety evaluation measures something else entirely. Its reported final unsafe-generation-presented rates on an adversarial evaluation set are:

Those percentages are safety measurements, not aesthetic-quality scores or acceptance rates for a production workflow.

What a discounted gateway changes—and what it does not

If I already needed a unified multi-model API, CometAPI would be one pricing route to evaluate: it advertises both variants at headline rates of $4/M input and $24/M output, a 20% discount against the corresponding official $5/M text-input and $30/M image-output rates.

The input wording needs scrutiny. Official pricing distinguishes $5/M text input from $8/M image input; a generic gateway “input” headline does not establish the rate for every reference-image token. I would verify live billing before budgeting an editing workload.

Using the same observed square-image token budgets, the output-only comparison is:

The volume totals use the underlying token calculations rather than rounded per-image values. They still exclude input costs and rework.

A discounted output rate helps, but it does not fix an inefficient approval process.

My production rollout would start with measurement

I would start at high, not max, for a production-quality evaluation. Then I would assign quality by workflow stage:

auto is also available, but the observed estimate table above does not give it a fixed token budget.

The useful property of this ladder is not just cheaper individual calls. It lets the pipeline generate concepts at medium, refine selected candidates at high, and reserve xhigh or max for the few assets that justify it.

Keep enough telemetry to reconcile the bill

For every request, I would retain:

• Model and snapshot, where applicable
• Quality setting and image dimensions
• Text-input, image-input, and image-output token counts
• Cached-input usage where reported
• Retry count
• Whether the result was accepted

Before scaling, I would run a representative batch at the intended dimensions and quality, calculate spend from actual usage, and divide by accepted assets. That captures prompt costs, reference-image costs, retries, and rejection rates that a static table cannot.

My starting configuration would be Flare for generation, Sunburst for edits where precision reduces rework, and higher quality only after selection. The target is not the cheapest request. It is the cheapest reliable path to an approved image.