GuidesOneMux

GPT Image 2.6 Sunburst API costs for structured extraction: a planning guide

Estimate an image-to-JSON workload with explicit token assumptions, schema validation, retries, and pricing limitations.

AI

Summary · TL;DR

A cost-planning guide for image-to-JSON extraction that separates published image-token rates from unknown text-output prices and accounts for validation and retries.

Key Takeaways

  • The supplied source reports a $8-per-million image-input-token rate, but does not establish a text-output rate for the proposed extraction workflow.
  • The OneMux catalogue snapshot lists Sunburst prices and its discount ratio as unknown; unknown is not free.
  • A schema-valid JSON response is not necessarily a correct extraction, so budget for both validation and task-level review.
  • Confirm that the chosen endpoint supports image input, text output, and the required schema behavior before treating Sunburst as an extraction option.
On this page (8)

The decision: verify the workflow before estimating its price

For structured extraction, the useful unit is one accepted JSON record from one source image, not one generated image. GPT Image 2.6 Sunburst has reported image-token rates, but the supplied pricing source does not establish that its endpoint supports image-to-JSON extraction or schema-constrained text output. It also does not provide the text-output rate needed to price that workflow. Confirm those details with the provider before funding a batch.

This is a cost guide from OneMux, the publisher and a model-access product. OneMux provides an OpenAI-compatible API, but compatibility for this particular workflow depends on the documented endpoint, model and parameters. The calculations below are illustrative, not measured requests.

Published rates and what they do—and do not—cover

The source pricing guide reports the following OpenAI rates for Sunburst, checked November 5, 2026. All amounts are US dollars per 1 million tokens.

Billing categoryReported official priceOneMux published priceOneMux published discount ratio
Text input$5.00UnknownUnknown / not discounted
Image input$8.00UnknownUnknown / not discounted
Text outputUnknownUnknownUnknown / not discounted
Image output$30.00UnknownUnknown / not discounted

The OneMux catalogue snapshot was captured November 17, 2026. Its Sunburst model page lists pricing as unknown in that snapshot, so the source's official rates are not a OneMux quote. Check current OneMux pricing and the actual provider's terms before using an estimate for procurement. No published discount can be calculated from unknown prices.

The source also reports cached text input at $1.25 and cached image input at $2.00 per million tokens. It does not establish cache eligibility for every Sunburst endpoint or request. Exclude cache savings until usage and billing records confirm them. Check applicable tiers separately; none are specified in the supplied snapshot.

The $30 image-output rate is relevant to generated image tokens, not automatically to a JSON response. Substituting it for an unknown text-output rate would produce an unsupported extraction estimate. Likewise, an image's dimensions or file size alone do not establish its billed image-token count.

A reproducible extraction estimate

Suppose you want 10,000 accepted invoice records. The following inputs are planning assumptions, not Sunburst measurements or a claim of endpoint support:

  • Each attempt uses 1,000 image input tokens and 500 text input tokens.
  • Each attempt returns 200 text output tokens.
  • The text-output price is hypothetically $20 per million tokens, solely to demonstrate the arithmetic. Replace it with the verified rate for the actual endpoint and model.
  • Eighty percent of attempts produce an accepted record. Rejected attempts have the same average token use as accepted attempts.
  • No caching, tiers, extra model calls, taxes, storage or human-review costs are included.
Component per attemptCalculationIllustrative cost
Image input1,000 × $8.00 / 1,000,000$0.0080
Text input500 × $5.00 / 1,000,000$0.0025
Text output200 × hypothetical $20.00 / 1,000,000$0.0040
TotalSum of the three components$0.0145

At an 80% acceptance rate, the expected workload is 10,000 / 0.80 = 12,500 attempts. At $0.0145 per attempt, the illustrative API total is $181.25, or $0.018125 per accepted record. This is an expectation under the stated assumptions, not a spending cap. Real retry limits, variable document complexity and different token use on failed attempts can change the total.

If acceptance falls to 50% and all other assumptions remain unchanged, the workload rises to 20,000 attempts and $290, or $0.029 per accepted record. That sensitivity is often more useful than a per-request price alone.

For a live estimate, replace every assumed token count and rate with the corresponding observed usage and applicable price. Keep image and text input separate. If usage reports an input total and a breakdown, do not add both. If the breakdown or text-output price is unavailable, report a partial estimate rather than inventing the missing amount.

Define acceptance before running a pilot

A schema catches structural problems; it cannot prove that the model read an invoice correctly. For a small pilot, define a narrow record and reject missing required fields. For example, this JSON Schema specifies an invoice identifier, a three-letter currency code and a nonnegative total in minor currency units:

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "invoice_id": { "type": "string", "minLength": 1 },
    "currency": { "type": "string", "pattern": "^[A-Z]{3}$" },
    "total_minor_units": { "type": "integer", "minimum": 0 }
  },
  "required": ["invoice_id", "currency", "total_minor_units"],
  "additionalProperties": false
}

Validate returned JSON locally with a validator that supports the declared schema version. A value such as 1250 represents 12.50 only for currencies with two minor-unit decimal places; define currency-specific handling in the application. The pattern checks the code's shape, not whether it is a real currency. Compare extracted values with the source image as a separate correctness check.

Before the pilot, confirm that the provider's documented route accepts the image and can return text in the required format. If it supports server-side schema enforcement, check its supported schema subset; the example above is not a claim that the endpoint accepts it. Otherwise, use local validation only if the endpoint can return usable JSON. If these capabilities are unavailable or undocumented, evaluate a documented vision-capable extraction model instead; price and test that model on its own terms.

Record costs and troubleshoot failures

Start with a small, representative set of documents and a spending limit. For every attempt, record the model and endpoint, image characteristics, returned usage breakdown, applicable prices, billed amount when available, validation outcome and review outcome. Record retries and rejected responses too. Do not assume an unsuccessful HTTP request is billed, or free; check the provider's terms and records.

Common failure cases deserve different responses:

  • Invalid JSON or missing fields: inspect the response, validate locally and revise the prompt or schema only where the endpoint supports it.
  • Valid but incorrect values: review legibility, ambiguous layouts and currency conventions. Schema validation alone will not catch a plausible wrong total.
  • No image-token breakdown or text-output price: keep the total marked incomplete and ask the provider for the missing billing detail.
  • Repeated rejection: set a retry limit and send unresolved documents for review rather than assuming acceptance will eventually be achieved.

Use the pilot's total observed cost divided by accepted records for a practical estimate, while retaining the underlying attempt count and noting any review costs excluded. A larger batch may have a different document mix and acceptance rate.

Conclusion

Sunburst's reported image-input rate can inform one component of an extraction budget, but it is not a complete image-to-JSON price. Verify workflow support and text-output billing first; then measure token use and acceptance against your own schema and documents.

Sources

Published price snapshot

Captured 2026-11-17T20:00:05.964Z 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.

ModelOfficial inputOfficial outputOneMux inputOneMux outputPublished price ratio
GPT Image 2.6 SunburstUnknownUnknownUnknownUnknownUnknown / not discounted

Current OneMux prices. Compare workload costs only when input/output and billing units match; see each model page for tier conditions.

FAQ

What does GPT Image 2.6 Sunburst cost for JSON extraction?

A complete price cannot be established from the supplied information. The source reports $8 per million image input tokens and $5 per million text input tokens, but does not provide the text-output rate or establish support for the proposed extraction workflow. OneMux prices were unknown in the supplied catalogue snapshot.

Can I use the image-output rate to estimate JSON output?

No. The source's $30-per-million rate is for image output tokens. Verify the applicable text-output rate for the actual endpoint and model instead.

Does valid JSON mean an extraction is accurate?

No. JSON Schema can check structure and value constraints, but a valid invoice number or total can still be wrong. Compare extracted values with source documents and include rejected attempts in the workload estimate.

Related articles