GPT-6 Astra costs $10 per million uncached input tokens and $50 per million output tokens on OpenAI's direct API—but only for Standard processing at 272,000 input tokens or fewer. Cached input is $1 per million and cache writes are $12.50 per million in that same band. OpenAI's current API price table lists a different, higher row once a request exceeds the input threshold.
That makes the useful buying question bigger than “Is Astra $10 in and $50 out?” Before committing a workload, verify that your API project can call gpt-6-astra, calculate the bill from all four token categories, add processing and tool charges, and compare cost per accepted task with your current model.
Prices and availability details below were checked on September 4, 2026. They cover OpenAI's direct API in USD, not ChatGPT subscriptions, negotiated contracts, taxes, purchased credits, or AWS billing.
The price card has two context bands
OpenAI publishes four token rates because ordinary input, cache hits, cache creation, and generated output do not cost the same. The Standard rates are:
| Billed token category | 272K input tokens or fewer | More than 272K input tokens |
|---|---|---|
| Uncached input | $10.00 | $20.00 |
| Cached input | $1.00 | $2.00 |
| Cache writes | $12.50 | $25.00 |
| Output | $50.00 | $75.00 |
All prices are per 1 million tokens. The GPT-6 Astra model page states the threshold rule directly: more than 272K input tokens doubles the input and cache rates and raises the output rate by 50% for the full request. Cache writes are billed at 1.25 times the uncached-input rate.
The threshold is a price boundary, not the model's maximum capacity. The same model page lists a 1,050,000-token context window, up to 922,000 input tokens, and up to 128,000 output tokens. A request can therefore fit within the model's limits and still move into the higher price band.
Two details are easy to miss:
- The condition is more than 272K input tokens. A request at the boundary remains in the short-context band; one just above it switches bands.
- Output also moves to the long-context rate. Pricing only the input above 272K at $20 while leaving the rest at the lower rates understates the bill.
Verify access with the project that will pay the bill
Do not treat a public model page, a ChatGPT model picker, or another company's successful request as proof that your API project has access. OpenAI's Astra announcement describes a phased rollout that began with a limited set of organizations. The current model page lists the API Free tier as unsupported and says rate limits depend on usage tier; detailed RPM and TPM limits are a separate, account-specific planning task.
Use the same project credentials and organization settings intended for the pilot. A minimal Responses API call keeps the access check separate from migration problems:
bashcurl https://api.openai.com/v1/responses \ -H "Authorization: Bearer $OPENAI_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "gpt-6-astra", "reasoning": { "effort": "low" }, "input": "Reply with exactly: access confirmed" }'
A successful model response confirms that this project could invoke Astra at that moment; record the returned model identifier with the test result. If the request fails, preserve the HTTP status and response body, then check the project and organization that issued the key. Do not infer a universal access date or assume that every failure has the same message.
An older application payload can also fail for reasons unrelated to rollout. OpenAI's current migration guidance says Astra supports reasoning.effort from low through max, but not none; it also tells migrations to remove temperature, top_p, top_logprobs, and the applicable logprobs fields. For tool calling, the guide recommends the Responses API. Start with the minimal request above, then add your production settings one at a time.
Calculate one bill from measured token categories
For one request or an aggregated workload slice, separate the measured token counts into their billed categories. Do not count the same token as both uncached and cached input.
texttoken subtotal = (uncached input / 1,000,000 × input rate) + (cached input / 1,000,000 × cached-input rate) + (cache writes / 1,000,000 × cache-write rate) + (output / 1,000,000 × output rate)
Suppose a short-context Standard workload records:
- 20,000 uncached input tokens
- 80,000 cached input tokens
- 20,000 cache-write tokens
- 5,000 output tokens
The Astra subtotal is:
| Component | Calculation | Cost |
|---|---|---|
| Uncached input | 20,000 / 1M × $10 | $0.20 |
| Cached input | 80,000 / 1M × $1 | $0.08 |
| Cache writes | 20,000 / 1M × $12.50 | $0.25 |
| Output | 5,000 / 1M × $50 | $0.25 |
| Token subtotal | $0.78 |
This is reproducible rate-card arithmetic, not an observed invoice. It assumes the measured categories are accurate and does not yet include tools, regional processing, tax, retries, or human review.
Cache hits can change the economics quickly, but only when they actually occur. For example, if the bill records a stable 1-million-token prefix once at the $12.50 cache-write rate and a later use entirely at the $1 cached-input rate, those two uses cost $13.50 for input instead of $20 if both were uncached. If the prefix changes or expires before reuse, the projected savings disappear. Budget from recorded cache-write and cached-input counts rather than an assumed hit rate. When migrating from GPT-5.5 or earlier, the model guide specifically calls for prompt_cache_options.ttl: "30m" in place of the older cache-retention parameter.
Crossing 272K reprices every token in the request
Consider a Standard request with 300,000 uncached input tokens, no cache activity, and 20,000 output tokens. The request exceeds the threshold, so every input token uses the $20 long-context rate and every output token uses the $75 long-context rate:
textinput: 300,000 / 1,000,000 × $20 = $6.00 output: 20,000 / 1,000,000 × $75 = $1.50 total: $7.50
The discontinuity matters even when only one input token crosses the line. With the same 20,000-token output, 272,000 uncached input tokens cost $3.72 at Standard short-context rates. At 272,001 input tokens, the request costs about $6.94 because the higher rates apply to the whole request.
This does not mean you should always trim a prompt below 272K. Retrieval, summarization, or splitting a task can remove context that the model needs and can create extra requests. Treat 272K as a workload boundary: measure tasks below and above it separately, then compare both quality and total cost.
Processing mode, region, and tools change the subtotal
After selecting the correct context band, apply the processing mode. OpenAI's direct API price table makes Batch and Flex half of Standard, while Fast is twice Standard:
| Processing mode | Relative token rate | $0.78 example at the same token mix |
|---|---|---|
| Batch | 0.5× Standard | $0.39 |
| Flex | 0.5× Standard | $0.39 |
| Standard | 1× | $0.78 |
| Fast | 2× Standard | $1.56 |
The table compares token prices, not delivery guarantees. Availability and latency behavior vary. The current request value is service_tier: "fast"; OpenAI also accepts the older priority value. In particular, the latest-model guide says Astra Fast mode has no latency SLA and is unavailable with EU data residency; those requests must use Standard processing.
The pricing terms apply a 10% uplift to eligible regional-processing or data-residency endpoints for qualifying models released on or after March 5, 2026. Do not add 10% to every Astra estimate automatically. Confirm that the endpoint and project are eligible, then multiply the applicable token subtotal by 1.10. The $0.78 Standard example would become $0.858 before tools and tax.
Tools are additional. The OpenAI API pricing page lists web search at $10 per 1,000 calls, or $0.01 per call, plus search-content tokens billed at the selected model's rate. Three search calls would therefore add $0.03 plus their search-content tokens. File-search calls and storage, and hosted containers, have their own charges. The Responses and Chat Completions endpoints do not carry a separate access fee; usage is what is billed.
A practical all-in estimate is therefore:
textall-in API cost = token subtotal at the applicable context band × processing-mode multiplier × eligible regional multiplier + tool-call and tool-usage charges
Keep tax, contractual discounts, and provider-specific billing outside that formula until you have the applicable terms. If you use Astra through Amazon Bedrock, AWS owns the bill; OpenAI's direct-API rates above do not establish the AWS price.
Decide with cost per accepted task, not cost per attempt
Astra's current direct-API token rates are 2.5 times GPT-5.6 Sol's when the token mix, context band, and processing mode are identical. For the $0.78 short-context example, the same mix would cost $0.312 on Sol. That is a useful baseline, but it says nothing by itself about which model completes your work more reliably.
The relevant denominator is accepted work:
textcost per accepted task = (API spend for successful and failed attempts + human review and repair cost + other workflow cost) / accepted tasks
If both models use the same number and mix of tokens per attempt, Astra must finish the workload with about 40% as many billable attempts as Sol to reach token-cost parity. Put another way, the premium is not recovered merely because Astra's acceptance rate is somewhat higher. It must prevent enough retries, human repair, or downstream failure to close the gap.
Run a bounded pilot on representative tasks for which failure is expensive enough to matter:
- Define acceptance before running either model. Use a test, rubric, or human decision that matches production.
- Keep direct costs comparable: record the model ID, processing mode, input band, reasoning effort, tool use, and the four token categories for every attempt.
- Track rejected outputs, retries, review minutes, repair minutes, and any manual steps the model removes.
- Separate tasks above 272K from shorter tasks so the price-band jump is visible.
- Compare total cost per accepted task and the business value of the accepted result—not average token price or one impressive example.
Pilot Astra where your current workflow creates costly rejects or manual repair, and only when you can score the result. Keep the cheaper model for work it already completes reliably. Use Batch or Flex when their operating behavior fits the job; pay for Fast only when lower delay is valuable enough to justify the multiplier, without assuming an SLA.
The decision is deliberately workload-specific. First verify gpt-6-astra in the paying project. Then replay a measured task set, price every category and add-on, and expand usage only where the accepted-task result clears your threshold.
