Astra 272K pricing: the long-context cost cliff

The rule OpenAI publishes

Two sentences on the official pages say the same thing in different words. The GPT-6 Astra model page says prompts with more than 272K input tokens are priced at 2× input and cache rates and 1.5× output for the full request. The API pricing page labels its columns “short context” and “long context,” and the footnote under the tier tables says short context is ≤272K input tokens and long context is >272K input tokens.

Read together, that means:

• 272,000 input tokens stays on the short-context card.
• 272,001 input tokens moves the entire request to the long-context card.
• The higher rates apply to cached input and cache writes as well as ordinary input. “Cache rates” on the model page covers both. The pricing table shows long-context cache writes at $25, which is 2× the $12.50 short-context write rate, and long-context cached input at $2, which is 2× the $1 read rate.
• Output is ×1.5, not ×2. Standard output goes from $50 to $75 per 1M, not to $100.
• There is no band of tokens billed at the old rate. A 400,000-token prompt is not 272,000 at $10 plus 128,000 at $20.

The model can accept far more than 272K. The model page lists a 1,050,000-token context window and a maximum of 922,000 input tokens. The cliff is a price step inside that window, not the maximum context.

What counts toward 272K

The threshold is input tokens, the same input_tokens field on the usage object. For GPT-6 Astra that total is the sum of three billed slices, which the API cost page defines:

• Ordinary uncached input
• Cached input (cached_tokens)
• Cache writes (cache_write_tokens)

Cache writes belong in the sum because they are input tokens. The caching guide is explicit that a write is a billing category inside the prompt, not a second copy of those tokens added on top. A request with 260,000 ordinary tokens and 20,000 tokens written to cache is 280,000 input tokens and is long context, even though no single line looks over the line by itself.

260,000 ordinary + 20,000 cache writes = 280,000 input tokens → long context
If the write were left out of the test, this request would be priced
as short context and the bill would be short by about half on input.

Long-context Standard:
  ordinary  260,000 / 1e6 × $20.00 = $5.20
  writes     20,000 / 1e6 × $25.00 = $0.50
  per request                      = $5.70

Short-context Standard (wrong for this prompt):
  ordinary  260,000 / 1e6 × $10.00 = $2.60
  writes     20,000 / 1e6 × $12.50 = $0.25
  per request                      = $2.85

Output tokens, including reasoning tokens, do not move the threshold. A short prompt with a 50,000-token completion is still short context. The completion is then billed at the short-context output rate ($50 / 1M on Standard), not $75.

Do not add cache writes twice. If you paste usage.input_tokens into the calculator’s uncached field, leave cached input and cache writes at zero — or, better, split the total into the three fields so the cheaper slices keep their own rates. The cliff test adds the three fields. Double entry both inflates the price and can trip the cliff early.

The jump at 272,000 versus 272,001

Hold output at 8,000 tokens and use Standard, with no cache. The only change is one input token.

One extra input token adds about $2.92 on Standard, almost all of it from repricing the first 272,000 tokens and the output, not from the new token itself. At 1,000 requests a day that gap is about $87,600 over 30 days ($3.12 × 1,000 × 30 = $93,600 versus $6.04002 × 1,000 × 30 = $181,200.60). If you are near the line, it is worth counting tokens before the call and cutting or splitting the prompt.

The same step exists on every tier, because each tier has its own published long-context columns. Fast at this boundary goes from $6.24 to $12.08004 per request (2× the Standard pair). Ultrafast goes from $18.72 to $36.24012 (6× the Standard pair). Those ratios match the short-context and long-context tables; the next section lists the published cells rather than asking you to multiply.

Published long-context card

USD per 1M tokens for gpt-6-astra when input tokens are greater than 272K. Copied from the long-context columns of OpenAI’s API pricing tables, last checked October 13, 2026.

Each long-context row is the short-context row with input, cached input, and cache writes doubled and output multiplied by 1.5. Batch and Flex long-context rates are also half of Standard long-context. Fast long-context is double Standard long-context. Ultrafast long-context is six times Standard long-context. If a future pricing page breaks that pattern, trust the table on OpenAI’s pricing page over the multiplier.

Regional-processing endpoints add a further 10% for models released on or after March 5, 2026, and FedRAMP endpoints add 10% as well. The pricing page does not say to stack them. A Standard long-context input token at one 10% uplift is $22 per 1M, not $24.

Worked long-context requests

Cached prefix that still crosses the line

200,000 ordinary input, 100,000 cached input, no cache writes, 20,000 output. Input total is 300,000, so the cliff is on. Caching still discounts the reused slice — $2 / 1M instead of $20 / 1M — but it does not keep the request on the short-context card, and it does not exempt the cached tokens from the 2×.

Standard long context:
  Uncached  200,000 / 1e6 × $20 = $4.00
  Cached    100,000 / 1e6 × $2  = $0.20
  Output     20,000 / 1e6 × $75 = $1.50
  Per request                   = $5.70

Same tokens if they had stayed at 272,000 or under (they do not):
  Uncached  200,000 / 1e6 × $10 = $2.00
  Cached    100,000 / 1e6 × $1  = $0.10
  Output     20,000 / 1e6 × $50 = $1.00
  Per request                   = $3.10

The cache saves $1.80 against an all-uncached long-context prompt (300,000 × $20 / 1M = $6.00 of input, plus $1.50 of output, is $7.50). It does not save the $2.60 gap versus a short-context bill. At 100 requests a day the long-context request is $17,100 over 30 days.

Same 300K prompt on cheaper and faster tiers

Flex/Batch math: 0.2 × $10 + 0.1 × $1 + 0.02 × $37.50 = $2.00 + $0.10 + $0.75 = $2.85. Fast is double the Standard $5.70. Ultrafast is six times it, which is also 0.2 × $120 + 0.1 × $12 + 0.02 × $450. A long-context Ultrafast workload is the most expensive combination on this page. Use it only when that latency is worth more than the token bill, and confirm Astra Ultrafast rate limits first (the Ultrafast guide lists default TPM of 500,000 on Build, 1,000,000 on Launch, and 5,000,000 on Grow).

Output-heavy, still short context

40,000 input tokens and 80,000 output tokens never sees the cliff. Standard cost is 0.04 × $10 + 0.08 × $50 = $0.40 + $4.00 = $4.40. The output dominates. Shrinking the answer, or lowering reasoning effort so fewer reasoning tokens land inside output_tokens, changes this bill more than cache policy does. Crossing 272K would reprice that same 80,000-token completion at $75 / 1M ($6.00) even if you only added input.

Staying under the line on purpose

The cliff is a property of one request’s input token count. These are the levers that change that count, without inventing a discount OpenAI does not list.

• Count before you send. The token counting API accepts the same payload you would send to responses.create, including tools and images that a characters-divided-by-four estimate misses. If the count is just over 272,000, cut there. The calculator then only checks the bill, it does not discover the surprise.
• Split documents. Two requests of 200,000 input tokens each stay on the short-context card. One request of 400,000 does not. You pay two outputs instead of one, and you lose whatever the model would have seen across the whole corpus. Compare that output cost with the cliff before you merge the files. Two Standard calls at 200,000 input and 5,000 output are 2 × ($2.00 + $0.25) = $4.50. One call at 400,000 input and 5,000 output is 0.4 × $20 + 0.005 × $75 = $8.00 + $0.375 = $8.375.
• Cache the stable prefix, and still count the total. A cache hit lowers the rate on the reused tokens ($1 instead of $10, or $2 instead of $20 once you are over the line). It does not subtract them from input_tokens. A 300,000-token prompt with a perfect cache hit is still long context.
• Put the breakpoint before volatile text. On GPT-5.6 and later you can set explicit cache breakpoints. Tokens after the last breakpoint are ordinary input, with no write charge. That does not change the cliff test — those tokens still count — but it stops you paying $12.50 / 1M (or $25 / 1M once over the line) to write a suffix that will never match.
• Compaction cuts tokens and can miss the cache. The Agents API compacts earlier context as a session grows. OpenAI’s caching guide notes that compaction, summarization, or truncation changes the prefix from the first edited token, so later turns may not reuse the old cache entry. Compaction is still the right tool when the alternative is a long-context price on every turn. Price both: a shorter prompt on the short-context card plus one cache miss, versus staying long and keeping the cache.
• Watch tool definitions. Tools, schemas, and developer instructions are part of the rendered prompt and count as input tokens. A large tool list can push a moderate user message over 272K. Cache that list only if it stays byte-for-byte stable; reordering tools breaks the prefix.

Maximums still apply after you decide to go long. 922,000 is the published max input, and 128,000 is the published max output. A prompt that fits the context window can still be a long-context bill from the 272,001st input token onward.

Tier multipliers do not turn the cliff off

Batch, Flex, Fast, and Ultrafast each have long-context prices in the table above. Choosing Flex to “get half off” halves the long-context card; it does not put you back on the short-context card. The order of operations on this site matches those published cells: start from Standard short-context rates, apply 2× input and cache and 1.5× output when the input total exceeds 272,000, then apply the tier multiplier (0.5, 2, or 6). Because multiplication commutes, you get the same dollars if you start from the tier’s short-context card and then apply the cliff.

Fast mode’s older parameter name is priority. Ultrafast is only service_tier: "ultrafast". Neither name changes the 272K test. A long Ultrafast call is the bottom row of the table: $120 / $12 / $150 / $450 per 1M.

Related

• Astra pricing calculator — auto-detects the cliff from the three input fields
• Astra API cost — short-context cards, cache break-even, tier choice
• Agents API sandbox choices — container charges on top of these token rates