GPT-6 Astra Pricing Explained: Input, Cache, and the 272K Rule
GPT-6 Astra's $10 input rate is not the whole story. Here's how cached input, cache writes, output, and the 272K-token threshold change the bill — plus what meshcode abstracts away for you.
GPT-6 Astra has a large context window and several reasoning-effort levels, but its pricing table has more than one input number. A coding-agent session can touch regular input, cached input, cache write, and output in the same overall workflow. If you only remember the headline input rate, the rest of the bill can be surprising.
Here is the price structure in plain language.
The four numbers to know
GPT-6 Astra is priced at:
| Usage type | Price per 1M tokens | What it represents |
|---|---|---|
| Regular input | $10.00 | Input tokens processed normally |
| Cached input | $1.00 | Input served from an existing cache |
| Cache write | $12.50 | Input written into the cache |
| Output | $50.00 | Tokens Astra generates |
The first thing to notice is that cached input is much cheaper than regular input: $1 instead of $10 per million tokens. The second is that cache write is $12.50, which is higher than regular input. These are not contradictory prices; they describe different moments in the cache lifecycle.
Connect the Claude or Codex you already pay for — the rest runs on workers that cost a fraction.
Download meshcode →Cached input vs. cache write
Think of a long project context that the model may need again. When that context is reused from an existing cache, the matching input is charged at the $1 cached-input rate. When content is being written into the cache, the $12.50 cache-write rate applies.
So the cheap number is not a discount that applies automatically to every prompt. It is the rate for input that is actually being served from cache. A session that keeps reusing stable context can benefit from cached input; a session that constantly creates new cache content can see cache-write charges instead.
That distinction is easy to miss in an agent because the agent may repeatedly read the same repository context while also changing the prompt around it. The API-level line items are precise, but they are not always intuitive when you are thinking in terms of "one conversation."
The 272K-token threshold
GPT-6 Astra also has a threshold at 272K prompt tokens. When a prompt exceeds that threshold, the pricing multiplier applies to the entire request:
- Input and cache are charged at 2x.
- Output is charged at 1.5x.
This is a request-level rule, not just a surcharge on the tokens above 272K. That is why a very large repository context or an unusually long agent transcript deserves attention before you send it. Astra's context window is 1,050,000 tokens, so a prompt can fit within the context window and still cross the threshold that changes the price.
The maximum output is 128,000 tokens, and the available reasoning-effort levels are low, medium, high, xhigh, and max. Those capabilities are useful for long-horizon work, but they also make it more important to route each task deliberately.
Why coding agents make this harder to see
A coding agent does more than answer one question. It reads files, plans changes, calls tools, receives command output, and generates edits across multiple turns. The agent may send a stable project context repeatedly, which is exactly where cache behavior matters.
If you are calling the API directly, you need to reason about which part of each request is regular input, which part is cached, when a cache is written, and whether the prompt crossed 272K. That is manageable for a carefully instrumented service, but it is distracting when your real goal is to ship code.
How meshcode presents Astra
meshcode abstracts this API-level bookkeeping behind panel-level flat metering. You select GPT-6 Astra for a panel, and meshcode presents usage as a predictable panel charge rather than asking you to manually inspect every cache-read and cache-write line item.
That does not change OpenAI's published rates; it changes the surface you have to manage. You can still use Astra's large context and reasoning levels, but you do not have to turn every coding session into a billing audit. And because each panel can use a different model, you can keep Astra for the work that benefits from it and route routine work to a lower-cost model.
A practical way to think about the bill
- Stable context reused many times: cached input at $1/M can be the favorable path.
- New context being stored: cache write at $12.50/M is its own charge.
- Fresh prompt content: regular input at $10/M.
- Generated code and reasoning: output at $50/M.
- Very large prompt over 272K: input/cache 2x and output 1.5x for the whole request.
The simplest cost control is model routing. Use Astra where its reasoning is worth the premium, and use a cheaper model for repository exploration, routine edits, and repetitive verification.
👉 Download meshcode — Mac, Windows