GPT Image 2.6 Sunburst API Costs: A Production Retry and Recovery Budget
Estimate GPT Image 2.6 Sunburst workload costs using explicit token assumptions, acceptance rates, retry limits, and recovery rules.
Summary · TL;DR
A reproducible cost model for a production image workflow, with an illustrative rate card, retry arithmetic, and operational rules for ambiguous failures.
Key Takeaways
- Budget per accepted image, including rejected attempts and billable failures, rather than per successful API response alone.
- The OneMux snapshot lists Sunburst input and output prices as unknown; its published ratio is not enough to calculate a customer invoice.
- Set quality and complexity deliberately, measure actual usage, and verify endpoint and parameter support before deployment.
- Treat timeouts as ambiguous until you can reconcile the result; blind retries can create duplicate work and duplicate charges.
On this page (11)
For a production image workflow, budget GPT Image 2.6 Sunburst by cost per accepted image, not just cost per API call. A rejected render, a retry after a timeout, and an edit using an input image can all change the final bill.
The worked example below uses rates reported by an external source, not a verified OneMux quote. OneMux publishes this cost guide and offers model access through an OpenAI-compatible API, but its supplied Sunburst price snapshot does not disclose the input or output prices needed to estimate a OneMux invoice.
Start with the price evidence
The OneMux catalogue snapshot was captured on 2026-11-11 at 10:30:05 UTC. Unknown means unavailable in that snapshot, not free. The ratio is reproduced exactly as published; its presence does not supply the missing prices or establish the amount a particular workload will save.
| Model | Official input | Official output | OneMux input | OneMux output | Published price ratio |
|---|---|---|---|---|---|
| GPT Image 2.6 Sunburst | Unknown | Unknown | Unknown | Unknown | 0.11699999999999999 |
The snapshot does not provide Sunburst tier or cache prices. Check current OneMux pricing and the model page for applicable units and conditions before committing a budget.
Separately, the supplied OrcaRouter comparison reports the following OpenAI rates. Treat them as illustrative source-reported assumptions, not independently verified current rates or OneMux prices. The source describes quality and complexity settings but does not provide a complete price-by-tier schedule.
| Usage category | Source-reported rate | Unit |
|---|---|---|
| Text input | $5 | Per 1 million tokens |
| Image input | $8 | Per 1 million tokens |
| Cached text input | $1.25 | Per 1 million tokens |
| Cached image input | $2 | Per 1 million tokens |
| Image output | $30 | Per 1 million tokens |
Caching eligibility, metering, and any provider-specific conditions must be checked against the actual service. Do not apply a cache rate to all input merely because prompts repeat. For edits, include image-input usage; for text-only generation, do not invent an image-input charge.
Calculate a workload in comparable units
The following is an illustrative calculation, not a test or a prediction of Sunburst token usage. Assume each attempt produces one image, and all completed attempts consume the same usage:
| Assumption | Illustrative value |
|---|---|
| Required accepted images | 10,000 |
| Text input per attempt | 1,000 tokens |
| Image input per attempt | 2,000 tokens |
| Image output per attempt | 4,000 tokens |
| Cache benefit | None |
| Acceptance probability per attempt | 80% |
| Maximum attempts per job | Three |
| Attempt outcomes | Independent, with the same acceptance probability |
At the source-reported rates, one attempt costs:
- Text input: 1,000 ÷ 1,000,000 × $5 = $0.005.
- Image input: 2,000 ÷ 1,000,000 × $8 = $0.016.
- Image output: 4,000 ÷ 1,000,000 × $30 = $0.120.
- Total: $0.141 per attempt.
If 10,000 images pass on the first attempt, the model-usage cost is $1,410. That is a floor for this scenario, not the retry-inclusive budget.
With an 80% acceptance probability and at most three attempts, the expected attempts per job are 1 + 0.2 + 0.04 = 1.24. The probability of acceptance within the limit is 1 − 0.2³ = 99.2%. Thus, for a large set of similar jobs, expected cost per accepted image is approximately $0.141 × 1.24 ÷ 0.992 = $0.17625. Producing 10,000 accepted images therefore costs approximately $1,762.50 in model usage, assuming failed jobs can be replaced with comparable new jobs.
For a fixed submission of 10,000 jobs instead, expect 12,400 attempts, a $1,748.40 model-usage bill, and 9,920 accepted images. The remaining 80 jobs need manual handling or a separately budgeted recovery path. These are expectations, not guarantees; correlated failures, variable token use, storage, review labor, taxes, and other charges are excluded.
Configure the experiment before calculating a migration budget
The source comparison reports that Sunburst supports image generation and editing and that GPT Image 2.6 adds a complexity setting, alongside quality, which defaults to high if omitted. It also reports the generation and edit endpoint paths. Verify current endpoint names, accepted model identifiers, parameter values, and usage reporting in the service documentation before implementation. OneMux compatibility with a particular image endpoint or parameter is conditional on documented support; this workflow has not been tested through OneMux.
For a useful estimate:
- Select a representative sample of production prompts and edits. Record the requested size, quality, explicit complexity, and whether an input image is present.
- Define acceptance before reviewing results: for example, required subject, layout, and text legibility. Keep the same rubric across settings.
- Record text-input, image-input, cached-input, and output usage where reported, plus charges or billable usage for failed attempts. If a usage category is unavailable, label it unknown and reconcile against the invoice.
- Compare output tokens per attempt, accepted images per 100 attempts, and total cost per accepted image. The first helps diagnose changes in output usage; the last captures the economic effect of rejection and input costs.
- Repeat the calculation by workload class. A text-only generation and a multi-image edit should not share an assumed image-input count.
The source suggests testing an explicit complexity setting when migrating from 2.5, but it does not establish that any setting reproduces 2.5 behavior. Measure your own acceptance and usage rather than applying a published multiplier.
Retry and recovery rules for production
Use a durable job record with the request settings, attempt number, submission time, provider response or request identifier when available, usage, acceptance decision, and final asset location. Avoid storing sensitive prompts or images longer than your retention policy permits.
| Event | Action | Budget consequence |
|---|---|---|
| Invalid request or unsupported parameter | Stop; correct the request before resubmitting. | Do not assume a failed request is free; check reported usage and billing terms. |
| Rate limit or transient service error | Retry with capped exponential backoff and jitter, within the job deadline and attempt limit. | Include billable failed attempts if the provider reports them. |
| Timeout or lost response | Mark the attempt as unknown; reconcile using available request identifiers, status tools, logs, or asset records before retrying. | The original may have completed and may be billable. If reconciliation is impossible, explicitly accept duplicate-cost risk or send the job for review. |
| Image returned but rejected | Record the rejection reason; retry only if the rubric and attempt budget permit. | Count the returned image's usage even though it was not accepted. |
| Attempt limit reached | Stop automated retries and route to a review queue or a separately approved fallback. | Budget fallback work separately; do not assume another model or endpoint is equivalent. |
A client-side job ID helps your system avoid processing the same result twice, but it does not by itself make an API request idempotent. Use provider-supported idempotency or status recovery only where documented. Alert on rising unknown outcomes, rejection rates, and cost per accepted image; pause the queue when a spend or failure threshold is reached.
FAQ
Is the published OneMux ratio enough to calculate Sunburst cost?
No. The snapshot lists the model's official and OneMux input and output prices as unknown. A ratio without usable underlying prices, units, and applicable conditions cannot produce a defensible invoice estimate.
Should every failed image request be retried?
No. Fix invalid requests first, cap retries for transient failures, and reconcile timeouts where possible. A timeout does not prove that generation stopped or that no usage was billed.
Does the example include cached input?
No. It assumes no cache benefit. Apply cached rates only to usage reported as eligible and billed at those rates, then recalculate the cost per accepted image.
Conclusion
Use the example as a spreadsheet starting point, not a quote: replace every token count, acceptance rate, retry limit, and price with observed values. The operational decision is whether the cost of accepted outputs remains acceptable after recovery work—not whether a single successful request looks inexpensive.
Sources
- OrcaRouter: GPT-Image-2.6 vs GPT-Image-2.5 — source-reported model settings, API surface, and illustrative rate card.
- OneMux published catalogue snapshot, captured 2026-11-11 at 10:30:05 UTC — model price availability and published ratio shown above.
Published price snapshot
Captured 2026-11-11T10:30:05.778Z from the OneMux published catalogue. Prices retain website billing units; this is not a live benchmark. Tiered, cached or time-based billing may differ. Unknown values are not zero.
| Model | Official input | Official output | OneMux input | OneMux output | Published price ratio |
|---|---|---|---|---|---|
| GPT Image 2.6 Sunburst | Unknown | Unknown | Unknown | Unknown | 0.11699999999999999 |
Current OneMux prices. Compare workload costs only when input/output and billing units match; see each model page for tier conditions.
FAQ
Is the published OneMux ratio enough to calculate Sunburst cost?
No. The snapshot lists official and OneMux input and output prices as unknown. A ratio without usable underlying prices, units, and applicable conditions cannot produce a defensible invoice estimate.
Should every failed image request be retried?
No. Fix invalid requests first, cap retries for transient failures, and reconcile timeouts where possible. A timeout does not prove generation stopped or that no usage was billed.
Does the illustrative calculation include cached input?
No. It assumes no cache benefit. Apply cached rates only to usage reported as eligible and billed at those rates.
Related articles
Guides
GPT Image 2.5 Flare API Cost: A Production Estimate With Retry Rules
Estimate GPT Image 2.5 Flare workload costs using explicit token assumptions, then budget for retries and recover safely from ambiguous failures.
Guides
GPT Image 2.6 Sunburst API Costs: A Reproducible Evaluation Budget
Estimate Sunburst image-generation costs with explicit token assumptions, acceptance criteria, spending limits, and a repeatable test plan.
Guides
GPT Image 2.6 Sunburst API Costs: A Privacy-Aware Workload Estimate
Estimate GPT Image 2.6 Sunburst costs with comparable token rates, explicit retry assumptions, and a privacy-conscious pilot checklist.
Guides
GPT Image 2.5 API Cost: A Repeatable Evaluation for 100 or 1,000 Usable Images
Estimate GPT Image 2.5 workload costs using explicit token rates, acceptance criteria, test cases, and billed retries.