Astra API cost for GPT-6: tokens, cache, and tiers

Published short-context card

Short context on OpenAI’s pricing page means 272,000 input tokens or fewer. Prices below are USD per 1M tokens for gpt-6-astra. They are the numbers on the API pricing page and the GPT-6 Astra model page as of the last-checked date above, not a community guess.

Batch and Flex match half of Standard on every column. Fast matches double. Ultrafast matches six times Standard ($60, $6, $75, $300). The long-context columns — input and cache rates doubled, output ×1.5 for the whole request — are tabulated on the 272K pricing page so this page can stay on the short-context bill most calls actually generate.

The model snapshot listed for GPT-6 Astra is gpt-6-astra. The model page also lists a 1,050,000-token context window, a maximum of 922,000 input tokens, and 128,000 max output tokens. Those limits cap the bill; they are not extra prices.

Four lines, one input total

A Responses usage object reports input_tokens and output_tokens. For GPT-5.6 and later, including GPT-6 Astra, the input total splits into three billed slices. OpenAI’s caching guide and the platform’s own per-run cost examples treat them as a partition:

• Cached input — input_tokens_details.cached_tokens. Tokens read back from a matching prompt prefix. Standard rate $1 / 1M, which is 0.1× the $10 uncached input rate.
• Cache writes — input_tokens_details.cache_write_tokens. Tokens newly written at a cache breakpoint. Standard rate $12.50 / 1M, which is 1.25× uncached input. That 1.25× is the whole price of those tokens, not a surcharge added after a $10 charge.
• Ordinary uncached input — input_tokens − cached_tokens − cache_write_tokens. Everything else in the prompt, including tokens after the last breakpoint that you chose not to write. Standard rate $10 / 1M.
• Output — output_tokens (Chat Completions: completion_tokens). Visible text, tool-call text, formatting tokens, and reasoning tokens. Standard rate $50 / 1M. Reasoning tokens are not a separate SKU; the reasoning guide says they are billed as output tokens.

If those three input slices do not add up to input_tokens, stop and re-read the usage object before you budget. Putting the full input_tokens figure into “uncached” and then also filling cached input and cache writes double-counts the prompt.

Image inputs are part of the same input-token total. The GPT-6 Astra pricing section publishes text-token rates only; it does not list a separate image price. Count images with the token counting API rather than a character estimate, then price those tokens on the card above.

When a cache write pays for itself

Prompt caching is on by default for supported models. For GPT-5.6 and later the minimum cacheable prefix is 1,024 visible input tokens, and the only TTL value documented for prompt_cache_options.ttl is 30 minutes. A later request can reuse a prefix only while that entry is still available, and a reuse refreshes the lifetime without another write charge. Caches are not shared across organizations or across regional processing boundaries.

OpenAI’s caching guide gives the break-even shape at a 0.1× read rate: one write plus one full read costs 1.35× a single uncached pass, versus 2× if you process the prefix twice with no cache. One write plus nine reads costs 2.15×, versus 10× with no cache. Applied to Astra’s $10 Standard input rate, a 100,000-token prefix looks like this:

The write is more expensive than a normal input on that first call ($1.25 versus $1.00). The saving shows up on the second call. If the prefix changes before the breakpoint — a timestamp in the system prompt, a reshuffled tool list, a compacted history — the next request misses, and you pay the write again. Explicit mode lets you place the breakpoint before the part that changes, so the stable prefix is what gets written and the tail stays on the ordinary $10 rate with no write.

Output tokens are never cached by this mechanism. A chatty completion at $50 / 1M can dwarf a well-cached prompt. On Standard, 20,000 output tokens cost $1.00, the same as 100,000 uncached input tokens.

Five worked requests

Each example stays at or under 272K input tokens, so the short-context card applies. Monthly figures use 30 days. Run the same inputs on the calculator if you want the line-item breakdown copied out.

1. Standard, no cache

100,000 ordinary input tokens, 10,000 output tokens, 100 requests per day.

Input   100,000 / 1e6 × $10 = $1.00
Output   10,000 / 1e6 × $50 = $0.50
Per request                 = $1.50
Monthly  $1.50 × 100 × 30   = $4,500.00

2. Standard, warm cache

50,000 ordinary input, 50,000 cached input, 10,000 cache writes, 5,000 output. Input total is 110,000, still short context.

Uncached  50,000 / 1e6 × $10.00 = $0.500
Cached    50,000 / 1e6 × $1.00  = $0.050
Writes    10,000 / 1e6 × $12.50 = $0.125
Output     5,000 / 1e6 × $50.00 = $0.250
Per request                    = $0.925

At 100 requests a day that is $2,775 over 30 days, versus $4,500 for example 1, because half the prompt is a cache read and the completion is shorter. The $0.125 write is the price of refreshing 10,000 tokens, not an extra fee on the 50,000 already counted as a read.

3. Batch, same tokens as example 1

Batch lists at half of Standard. The same 100,000 / 10,000 request is $0.75. Monthly at 100 requests a day is $2,250. The Batch API completes each job within 24 hours (often sooner), with a separate rate-limit pool. It is the right tier for evals, enrichment, and other work that can wait. It is the wrong tier for a user waiting on a spinner.

4. Fast, same tokens as example 1

Fast lists at 2× Standard, so this request is $3.00, and the same daily volume is $9,000 a month. Set service_tier to fast. OpenAI’s Fast mode guide says priority is the previous name and still requests the same mode. If traffic ramps too quickly, some Fast requests can be served at standard speed and billed at standard rates; the response then reports service_tier: "default". Budget the Fast card only for calls that actually stay on Fast.

5. Ultrafast, same tokens as example 1

The published Ultrafast short-context rates are $60 input and $300 output per 1M.

Input   100,000 / 1e6 × $60  = $6.00
Output   10,000 / 1e6 × $300 = $3.00
Per request                  = $9.00
Monthly  $9.00 × 100 × 30    = $27,000.00

That is six times example 1, which matches the published Ultrafast columns divided by the Standard columns. Ultrafast is a service_tier of ultrafast on gpt-6-astra, available to all API users, with its own rate limits (default TPM of 500,000 on Build, 1,000,000 on Launch, and 5,000,000 on Grow). The Ultrafast guide recommends a WebSocket for agents that make many tool calls in a row, because a fresh HTTP connection can spend the latency you just paid for. GPT-6 Astra Ultrafast supports US data residency and global processing only.

Which tier to price

• Standard is the default when you omit service_tier and the project is not pinned to another tier. Use it for production traffic that needs a normal response time and the $10 / $50 card.
• Flex is the same token price as Batch, on a synchronous request. OpenAI describes it as slower, with occasional 429 Resource Unavailable responses that are not billed. Official samples raise the client timeout toward 15 minutes. Retry with backoff, or fall back to Standard, when a miss is worse than the extra cost.
• Batch is the 50% card for a file of requests. A batch holds up to 50,000 requests and the input file can be up to 200 MB. The completion window is 24 hours. GPT-6 Astra’s model page lists the Batch endpoint as supported.
• Fast is the 2× card when the product is waiting. Do not park a backfill on it. Priority processing was renamed Fast mode on July 30, 2026.
• Ultrafast is the $60 / $300 card when the product is waiting and Fast is still too slow. Check the separate TPM limits before you point a launch spike at it.

Reasoning effort does not have its own multiplier on the Astra token card. low, medium, high, xhigh, and max change how many tokens the model generates. none is rejected for GPT-6 Astra. Pro reasoning mode, where offered, bills the extra model work at the selected model’s token rates rather than a second price list — more tokens, same rates. Cap the total with max_output_tokens, and remember an incomplete response can still bill input plus reasoning tokens with no visible answer. OpenAI’s reasoning guide suggests leaving on the order of 25,000 tokens of headroom while you learn a prompt.

Charges that are not in the four lines

The calculator on the homepage prices tokens only. These published add-ons sit on the same invoice when you use them:

• Web search. The pricing page lists $10.00 per 1,000 calls for web search and image web search, plus search-content tokens billed at model rates. Those content tokens are input to the model, so on Astra they use the input card above, including the long-context multiplier if the whole prompt crosses 272K.
• File search. $2.50 per 1,000 tool calls on the Responses API, and $0.10 per GB-day of storage after 1 GB free.
• Containers. Hosted Shell and Code Interpreter are listed at $0.03 / $0.12 / $0.48 / $1.92 per 20-minute session for the 1 GB / 4 GB / 16 GB / 64 GB memory tiers, billed by the minute with a 5-minute minimum. The shape of OpenAI-hosted versus partner sandboxes is on the Agents API sandbox page. The Agents API harness itself has no extra fee; tokens are still this model card.
• Regional processing. Data-residency endpoints are charged a 10% uplift for models released on or after March 5, 2026. FedRAMP endpoints are also charged a 10% uplift. The pricing page does not say those two 10% uplifts stack. The calculator’s checkbox applies one 10%, not 21%.

A 10% uplift on example 1 turns $1.50 into $1.65 per request and $4,500 into $4,950 per month. Check the box only when the call actually goes to a regional-processing or FedRAMP endpoint.

The 272K cliff, in one paragraph

If input_tokens is greater than 272,000, OpenAI prices the entire request at 2× input and cache rates and 1.5× output. One token over the line reprices the tokens under the line as well. Standard long-context rates published for Astra are $20 input, $2 cached input, $25 cache writes, and $75 output per 1M. A 300,000-token prompt is not “272K at $10 and 28K at $20.” The boundary arithmetic, and the long-context card for every tier, is on Astra 272K pricing.

Subscription versus API

A ChatGPT subscription is a different product. Plus and Pro are seats with product allowances, not a pool of API tokens. In September 2026 OpenAI paused new ChatGPT Pro $200 (Pro 20X) sign-ups because of Astra demand; that pause does not edit the API card on this page. Confirm whether a consumer plan is open on OpenAI’s Pro help page. Enterprise ChatGPT token rate cards are also separate from this API table — read the rate card on your agreement if you are buying through ChatGPT Enterprise rather than api.openai.com.

Nothing on this site is an OpenAI invoice. Copy the usage fields from a real response, price them here, then match the result to the live pricing page before you commit budget.

Related

• Astra pricing calculator — per-request and monthly totals
• Astra 272K pricing — long-context rates and the boundary jump
• Agents API sandbox choices — container rates versus partner compute