2026.09.18 2026.09.22

Where the GPT-6 Astra Price Table Jumps Before You Fill a Million Tokens

swiftwand

Told that a model handles a million tokens of context, the natural impulse is to hand it everything. Datasheets, bills of materials, old records, manuals. If it removes the work of splitting things up, that alone is worth something.

This article contains affiliate links. As an Amazon Associate, we earn from qualifying purchases.

Then you open the price table and notice the rate column is not one column. Standard, batch, fast, and long context. If you are going to work with GPT-6 Astra pricing in earnest, the condition under which that column switches matters more than the rates themselves. The switch happens without announcing itself.

Our position first. We have not seen an actual invoice; every figure below is calculated from published rates. Taken from the developer’s price table and API reference as of 6 September 2026. No currency conversion — everything stays in US dollars.

The rate table as published
Only the long-context row breaks the pattern
The switch happens at 272,000 input tokens
Add 8,000 tokens, more than double the bill
A million-token window is not a million tokens of material
Longer input does not reliably mean better answers
Caching pays from the second use
Batch is half price if you can wait
Where this actually bites
Estimates go stale on their own
What we have not verified
In short
Sources

忍者AdMax

The rate table as published

All figures are US dollars per million tokens.

Tier	Input	Cached input	Cache write	Output
Standard	$10.00	$1.00	$12.50	$50.00
Batch	$5.00	$0.50	$6.25	$25.00
Fast	$20.00	$2.00	$25.00	$100.00
Standard, long context	$20.00	$2.00	$25.00	$75.00

Simple enough as a table, but three things are worth seeing. Batch is exactly half of standard. Fast is exactly double. And only the long-context row is irregular.

Before the rows, the columns. Input is charged on what you send — the instruction, the material you attached, the conversation so far. Everything sent is counted. Output is charged on what comes back, at five times the input rate. The longer the replies your use produces, the more the output side dominates the bill.

The three tiers — standard, batch and fast — are differences in speed and waiting. For the same model and the same capability, the rate changes according to how long you can wait. Between batch and fast the spread is fourfold, which is the sort of difference that usually comes from changing models.

Only the long-context row breaks the pattern

The fast row doubles input and output alike. The long-context row does not: input and cache double, but output goes from $50.00 to $75.00, which is 1.5x.

That asymmetry is stated explicitly in the API reference — 2x on input and cache rates, 1.5x on output, written out as separate multipliers. It is exactly the kind of detail a summary flattens into “double”.

Rounding rarely errs in the safe direction. Here it happens to: believing output doubles makes you over-estimate, which does no harm. But the same habit can run the other way. Get used to calculating from someone else’s summary and which direction you err in becomes luck. For a figure that comes out as money, opening the original is worth the trouble.

The switch happens at 272,000 input tokens

So when does the long-context row apply? The condition is unambiguous: when input exceeds 272,000 tokens. And critically, it is priced that way for the full request, not only for the tokens above the line.

Pricing tables make sense once you understand how foundation-model applications actually consume tokens.

AI Engineering: Building Applications with Foundation Models

USD 52.40 on Amazon.com (as of 2026/09/22)

Amazon

楽天市場

ポチップ

Add 8,000 tokens, more than double the bill

At exactly 272,000 input tokens, standard rates apply.

272,000 x $10.00 / 1,000,000 = $2.72

Add 8,000 tokens — 3% more — to reach 280,000, and the long-context rate takes over.

280,000 x $20.00 / 1,000,000 = $5.60

A 3% increase makes the bill 2.06 times larger. That is not the price of the extra 8,000 tokens; it is the whole request repricing.

Add output for a fuller comparison. At 10,000 output tokens, the standard case is $2.72 + $0.50 = $3.22, and the long-context case is $5.60 + $0.75 = $6.35 — still very nearly double.

How much headroom to leave is a matter of use, but operating just under the boundary does not pay. The loss from crossing it is far larger than anything you save by running close to it. On the figures above, begrudging 8,000 tokens and stepping over the line costs you many times what you were trying to save.

And the obvious remedy is available: 280,000 tokens of material split into two passes of 140,000 crosses nothing. The same total input, at standard rates.

A million-token window is not a million tokens of material

Since this is easy to confuse with the boundary, the ceiling deserves its own note.

The specified context window is 1,050,000 tokens and the maximum output is 128,000. The window is input and output combined, so “you can throw in a million tokens of material” does not follow. Assuming you use the output ceiling in full, roughly 920,000 tokens are left for material — though that figure is not published; it is a subtraction from the two that are. The same point is made in what GPT-6 Astra actually changed.

And being able to fill a ceiling is not a reason to. An input in the region of 900,000 tokens is far past the 272,000 boundary, so the whole request bills at the higher rates — 2x input and cache, 1.5x output. The ceiling is a technical limit, not a recommendation.

Longer input does not reliably mean better answers

Cost aside, look at the performance side too. On the benchmark measuring whether a model can retrieve what it needs from long context, the published values are 100.0% over the 256,000–512,000 token range and 96.3% over 512,000–1,000,000. The previous generation scored 91.5% and 73.8% respectively.

Retrieval over long ranges has clearly improved. But that says it can find the thing if the thing is in there. It does not say adding more makes the answer better. Unrelated material costs input charges with certainty and improves nothing with none.

Caching pays from the second use

Standard input is $10.00 while reading from cache is $1.00 — a tenth. If you send the same instruction sheet, the same design standards, the same glossary every time, that is a large lever.

Writing to the cache has its own rate, though. Cache write is $12.50, higher than ordinary input at $10.00. So putting something in that you use only once costs you more, not less.

The threshold is a count. Pay $12.50 to write and read at $1.00 thereafter, and you are ahead from the second use: two uses cost $13.50 cached against $20.00 uncached. Cache the standing preamble and nothing else is the plain conclusion.

Batch is half price if you can wait

Batch rates are exactly half of standard across every column. If the work does not need an answer now — overnight regeneration, a bulk pass over accumulated records, a parameter sweep — that is a 50% reduction for a scheduling change and nothing else.

The corresponding trap is fast mode. It is up to twice the speed at exactly twice the price, which is a fair trade when a person is waiting and a pure loss when nobody is. An unattended loop running on fast mode is paying four times batch rates for speed nobody experiences.

Where this actually bites

Pattern	What goes wrong	What to do instead
Attach the whole document set every time	Crosses 272,000 and reprices the request	Attach only the sections in scope
One long conversation that keeps growing	History is re-sent as input each turn	Start a fresh thread per task
Cache material used once	Cache write at $12.50 beats input at $10.00	Cache only the standing preamble
Fast mode on an unattended job	2x the price for speed nobody sees	Standard, or batch if it can wait
Sizing material against the full million	Output shares the window	Size against material, and check against the boundary first

The recurring shape is that none of these announce themselves. No error is raised when you cross 272,000; the bill simply arrives larger. That is what makes the boundary worth knowing rather than discovering.

Estimates go stale on their own

If you run this for any length of time, revisit actual usage periodically. An operation always grows. The preamble lengthens, the attached material multiplies, the history piles up. Assume that the estimate you made at the start will not be right three months later.

The specific risk is a workload that started comfortably under 272,000 and drifted over it. Nothing breaks; the unit rate simply doubles, and the change is visible only on the invoice.

What we have not verified

We have not reconciled any of this against a real invoice. Every figure is calculated from published rates.
Token counts for your own material depend on the content and the tokeniser; the worked examples use round numbers to show the shape of the effect, not to predict your bill.
Whether cache writes replace or add to the input charge in every case is modelled here as replacing on first use, which matches the published rate structure but which we have not confirmed against billing.
Regional and platform variations. Azure and Bedrock availability is stated, and rates there may differ from the direct API. Fast mode and Priority are noted as unavailable under EU data residency.

In short

The rates are easy. The structure is where the money goes.

Batch is half, fast is double, and only long context is irregular — 2x on input and cache, 1.5x on output. It triggers above 272,000 input tokens and applies to the whole request, so a 3% overshoot can double the bill. Splitting the material into two passes avoids it entirely.

Cache the preamble you reuse and nothing else, because the write rate exceeds ordinary input. Use batch whenever nobody is waiting, and keep fast mode for the cases where a person actually is.

And treat the million-token window as a ceiling rather than a target. Input and output share it, more material does not reliably improve the answer, and anything near the ceiling is billing at the higher tier by definition. The ceiling is where a design starts, not what it aims at.

For the specifications behind these numbers, see what GPT-6 Astra actually changed. For deciding which work is worth spending this on at all, see the reverse guide.