
GPT-6.2 Astra costs $8 per million input tokens, $0.40 cached, and $40 output, 20% below GPT-6 Astra on the sticker. The bigger change is cached input, down 60%. On a support agent that reuses a 12,500-token prompt, that makes it about 35% cheaper per ticket ($21.80 against $33.50 per 1,000), but only if the cache actually hits: a miss costs over 5 times more.
Watch three meters: prompts over 272K tokens, Fast mode, and Ultrafast, which goes from 3x to 6x Standard on 1 March 2027. For most support work, GPT-6.2 Sol does the same job at a quarter of the price.
How much does GPT-6.2 Astra cost?
GPT-6.2 Astra costs $8 per million input tokens and $40 per million output tokens at the Standard tier, with cached input at $0.40. OpenAI released it on 17 November 2026 alongside GPT-6.2 Sol, the successor to GPT-6.1 Sol. The launch post frames the price as "a 20% discount on input and output tokens, and a deeper 60% discount on cached input tokens" against GPT-6 Astra.

I build integrations and API plumbing at eesel, and I've spent the last few years putting AI agents on live support queues, so the first thing I do with a new model price is turn it into a cost per ticket. The sticker price per million tokens tells you almost nothing until you know which meter each token lands on. Here is every meter from OpenAI's pricing page and the GPT-6.2 Astra model page, per million tokens:
| Tier | Input | Cached input | 30-min cache write | 12-hour cache write | Output |
|---|---|---|---|---|---|
| Standard | $8.00 | $0.40 | $10.00 | $20.00 | $40.00 |
| Standard, over 272K input | $16.00 | $0.80 | n/a | n/a | $60.00 |
| Batch | $4.00 | $0.20 | $5.00 | $10.00 | $20.00 |
| Fast | $16.00 | $0.80 | $20.00 | $40.00 | $80.00 |
| Ultrafast (to 28 Feb 2027) | $24.00 | $1.20 | $30.00 | $60.00 | $120.00 |
| Ultrafast (from 1 Mar 2027) | $48.00 | $2.40 | $60.00 | $120.00 | $240.00 |
| Flex | Not offered |
The long-context row comes from the model page, which says that past 272K input tokens "input and cache rates double and output costs 1.5 times the short-context rate for the full request." It doesn't list long-context cache write prices, so I've left those blank rather than guess.
The model itself has a 1,050,000-token context window, 922,000 max input tokens, and 128,000 max output tokens. One more line on the model page affects cost: the API rejects requests that set reasoning effort to none, so you can't switch reasoning off to save output tokens the way some teams did on older models. Reasoning tokens bill as output, per OpenAI's reasoning guide.
What exactly are you billed for?
You're billed per token on four separate meters, and they cost wildly different amounts. Every request splits into:
- Input tokens at $8 per million: anything new in the prompt, like the customer's message.
- Cached input at $0.40 per million: the start of the prompt that matches a recent request exactly, like your instructions and help center text.
- Cache writes at $10 (30 minutes) or $20 (12 hours) per million: the first time a reusable prefix gets saved.
- Output tokens at $40 per million: the reply, plus any reasoning the model does before it.
OpenAI's prompt caching guide is clear that a cache write "is not an additive fee." Each input token is billed once, at either the uncached, cached, or write rate. The minimum cacheable prefix is 1,024 tokens for GPT-5.6 and later models.
The gap between those meters is the whole story. A cached token costs a twentieth of a fresh input token and a hundredth of an output token. So the shape of your prompt matters more than the headline price.
How much cheaper is it than GPT-6 Astra in practice?
On any workload that reuses a long prompt, GPT-6.2 Astra is about 35% cheaper than GPT-6 Astra, not 20%. The extra saving comes from the cached-input cut.
To check, I priced a typical support agent call. Each ticket sends a 12,500-token prefix (instructions plus help center content, the same size as the cache test I ran on launch day), 600 tokens of new input, and 300 tokens of output including reasoning. Assuming the prefix hits the cache:
| Model | Cached input | Input | Output | Per ticket | Per 1,000 tickets |
|---|---|---|---|---|---|
| GPT-6 Astra | $1.00 | $10 | $50 | $0.0335 | $33.50 |
| GPT-6.2 Astra | $0.40 | $8 | $40 | $0.0218 | $21.80 |
| GPT-6.2 Sol | $0.10 | $2 | $10 | $0.0055 | $5.45 |

Two things stand out. The first is that the reused prompt dominates the bill. In my GPT-6.2 Astra launch-day test, with a tiny 278-token prompt and no help center in it, 1,000 tickets cost $5.79 at medium effort. Add the knowledge an agent actually needs and the price goes up by roughly 4x, even with the cache working.
The second is the cache-miss bar. If that same prefix is billed as fresh input on every ticket, GPT-6.2 Astra costs $116.80 per 1,000 tickets, more than 5 times the cached price and more than GPT-6 Astra with a working cache. A missed cache wipes out the whole upgrade discount and then some.
Artificial Analysis sees the same direction at the benchmark level: its full Intelligence Index costs $4.00 per task on GPT-6.2 Astra against $6.24 on GPT-6 Astra, a 36% drop. That comes from cheaper tokens plus fewer of them, since OpenAI says the model uses fewer output tokens on demanding tasks.
What does a cache miss actually cost you?
A cache miss costs about 5 times more per ticket on GPT-6.2 Astra, and it's easier to trigger than you'd think. In my launch-day test, I put a 12,500-token help center into the top-level instructions field of the Responses API. Three calls in a row showed zero cached tokens and zero cache writes. Moving the same text into a developer message fixed it: the first call wrote 12,513 tokens to the cache, and the next two read 12,501 tokens each.
OpenAI's caching guide explains part of why. "Top-level instructions cannot contain an explicit breakpoint," it says, and reusable developer instructions belong "in an input_text block inside a developer message." The launch post also recommends "keeping prompt prefixes unchanged and appending new instructions" for both 6.2 models. If your integration rewrites the system prompt every turn to inject customer data, you're paying the full input rate on every token of it.
Cache writes have their own maths. A 30-minute write of a 12,500-token prefix costs $0.125, compared with $0.10 to send it uncached once. So the write loses money if nobody reuses the prefix, and pays for itself from the second hit. On GPT-6.2 Astra's rates, one write and nine reads cost 1.70 times the plain input price, against 10 times with no caching at all.
The 12-hour write costs twice as much ($0.25 for that prefix). It's worth it for a quiet queue: if tickets arrive more than 30 minutes apart overnight, a 30-minute cache keeps expiring and you pay to write it again each time. A busy queue doesn't need it, because each read refreshes the 30-minute window. You can watch hit rates in OpenAI's Prompt Caching Dashboard before deciding.
Which tiers and multipliers change the bill?
Eight multipliers sit on top of the Standard rate, and two of them are big enough to matter more than the model choice. Here they are on one ladder:

- Batch (0.5x). The Batch API halves every rate, including cached input and writes. It suits overnight jobs like tagging last month's tickets or rewriting help articles, not live replies.
- Background requests (0.6x to 0.7x). Per the pricing page, eligible background requests in the Responses API run "30% below Standard for the 2‑hour completion window and 40% below Standard for the 8‑hour completion window." It's in public beta.
- Data residency (1.1x). Regional processing endpoints carry "a 10% uplift for models released on or after March 5, 2026," which includes GPT-6.2 Astra. FedRAMP endpoints carry the same 10%.
- Fast (2x). Fast mode, which OpenAI renamed from Priority processing on 30 July 2026, doubles every rate.
- Ultrafast (3x, then 6x). Ultrafast costs 3 times Standard until 28 February 2027 and 6 times Standard from 1 March 2027. If you build a latency-sensitive feature on it now, your bill doubles on that date with no code change.
- Long context (2x input, 1.5x output). Cross 272K input tokens and the whole request moves to the higher rate, not just the tokens past the line.
The one tier you might expect and won't find is Flex. The pricing page lists Flex for GPT-6 Astra, GPT-6.1 Sol, GPT-6.1 Terra, and GPT-6 Luna, but not GPT-6.2 Astra. Batch and background requests are the discount routes for now.
The long-context rule is the sneakiest. A single 400,000-token contract review with a 4,000-token answer costs $6.64 on GPT-6.2 Astra. The same tokens at short-context rates would cost $3.36. If you can split a document into chunks under 272K, you halve the input bill.
What would GPT-6.2 Astra cost for your volume?
Plug in your own ticket volume and prompt shape below. It prices the same workload on GPT-6.2 Astra, GPT-6 Astra, and GPT-6.2 Sol, using the rates from OpenAI's pricing page. Cache misses are billed as 30-minute cache writes, which is what happens with implicit caching when the prefix isn't already saved.
Drag the cache hit rate from 95% to 0% and the GPT-6.2 Astra bill at 8,000 tickets jumps from $222.40 to $1,134.40 a month, about 5 times. That one setting moves the bill more than the model upgrade does.
What does it cost at different team sizes?
Here's the same support workload at three monthly volumes, on Standard rates with a 95% cache hit rate. Misses are billed as 30-minute cache writes:
| Monthly tickets | GPT-6.2 Astra | GPT-6.2 Astra, Batch | GPT-6 Astra | GPT-6.2 Sol |
|---|---|---|---|---|
| 1,000 | $27.80 | $13.90 | $40.69 | $6.95 |
| 8,000 | $222.40 | $111.20 | $325.50 | $55.60 |
| 50,000 | $1,390.00 | $695.00 | $2,034.38 | $347.50 |
For scale, eesel customer SamCart runs one agent on Freshdesk tickets and another on its website chat, answering from about 280 help center articles, on a plan that covers 8,000 interactions a month. That middle row is roughly that volume. On raw tokens alone, the model bill is a few hundred dollars a month, before anyone has written the retrieval, the function calling for order lookups, the escalation rules, or the observability to see what it said.
That's the honest shape of AI customer service cost: the tokens are the small line, and the retrieval layer is part of the bigger one. The engineering and maintenance around them are the big one, which is why the cost of an AI agent depends far more on build versus buy than on which model you pick.
Is GPT-6.2 Astra cheaper than Claude Fable 5.2?
Token for token, no: they have the same sticker price, and Fable's cache is cheaper. Per finished task, GPT-6.2 Astra is far cheaper. Anthropic's pricing page lists Claude Fable 5.2 at $8 input and $40 output per million tokens, exactly matching Astra, with cache hits at $0.20.
| Per million tokens | GPT-6.2 Astra | Claude Fable 5.2 | Claude Opus 5.5 | GPT-6.2 Sol |
|---|---|---|---|---|
| Input | $8.00 | $8.00 | $4.00 | $2.00 |
| Output | $40.00 | $40.00 | $20.00 | $10.00 |
| Cache read | $0.40 | $0.20 | $0.20 | $0.10 |
| Cheapest cache write | $10.00 (30 min) | $10.00 (5 min) | $5.00 (5 min) | $2.50 (30 min) |
| Long prompts | 2x input, 1.5x output over 272K | Same rate to 1M | Same rate to 1M | 2x input, 1.5x output over 272K |
| AA Intelligence Index | 62 | 65 | 59 | 57 |
On my support workload with a cached prefix, Fable 5.2 actually comes out slightly cheaper ($19.30 against $21.80 per 1,000 tickets) because of that $0.20 cache read. And for one 400K-token request, Fable costs $3.36 where Astra costs $6.64, because Anthropic charges "the same per-token rate" across the full 1M context window.

The per-task view flips it. Artificial Analysis puts the cost to run its Intelligence Index at $4.00 per task for GPT-6.2 Astra against $26.54 for Claude Fable 5.2, because Astra uses far fewer tokens to get to an answer. Fable still scores higher, 65 to Astra's 62. On long agent tasks where the model writes and reasons a lot, the token count matters more than the rate card. On short, cache-heavy calls like support replies, the rate card matters more.
So the right comparison depends on your workload. For short replies with a big reused prompt, compare cache rates. For long, open-ended work, compare cost per task. Claude Opus 5.5 sits in between at half Astra's token price and a lower score. The GPT-6 Astra alternatives roundup covers the rest of the field.
What does GPT-6.2 Astra cost in ChatGPT?
In ChatGPT you pay a flat subscription, not per token. OpenAI says GPT-6.2 Astra and Sol are "available to all Plus, Pro, Enterprise, and Edu users in ChatGPT Work and Codex," with Enterprise and Edu access once a workspace admin turns it on.
| Plan | Price | GPT-6.2 Astra access |
|---|---|---|
| Free | $0 | Not listed in the launch post |
| Go | $8/month | Not listed in the launch post |
| Plus | $20/month | Yes, in ChatGPT Work and Codex |
| Pro | From $100/month (Pro 100, Pro 200, Pro 500) | Yes; Pro 500 also gets Ultrafast with Astra |
| Enterprise and Edu | Contact sales | Yes, once an admin enables it |
Prices come from ChatGPT's pricing page. Pro tiers also include monthly API credits: $100 with Pro 100, $200 with Pro 200, or $500 with Pro 500. At my cached support rate of $21.80 per 1,000 tickets, $500 of credits covers about 22,900 GPT-6.2 Astra tickets a month, as long as you meet OpenAI's eligibility terms for the credits. The full plan breakdown lives in the ChatGPT pricing guide.
Is GPT-6.2 Astra worth the price for customer support?
For most support queues, GPT-6.2 Astra is more model than the job needs. In my launch-day test, GPT-6.2 Sol and GPT-6.2 Astra both handled all 15 test tickets correctly, including refund maths, a prompt injection, and a failed order lookup, and Sol cost about a quarter as much. OpenAI's agent evals tooling can run the same kind of check on your own tickets. Astra earns its price on long, multi-step work like financial models, legal research, and spreadsheet builds, which is where OpenAI points it.
There's also a reason beyond cost to keep Astra away from unsupervised customer replies. Artificial Analysis found its hallucination rate on unknown facts rose from 50% to 59% at max effort compared with GPT-6 Astra. That makes the grounding and hallucination prevention layer more important than the model choice, whichever one you run.
The bigger budgeting question is whether you want a token bill at all. Token pricing moves with every prompt change, every cache miss, and every pricing update like the Ultrafast change in March. One engineering lead at a crypto-hardware company with a 300+ article knowledge base put the choice like this when they picked eesel:
"We could try to write our own LLM application but we didn't want to invest our time into that. We wanted something that we would not have to maintain."
That's the build vs buy trade in one line. If you build on GPT-6.2 Astra, budget for the tokens and the upkeep. If you buy, budget a fixed monthly number and spend your time on testing the agent against real tickets instead.
Try eesel
If you're pricing GPT-6.2 Astra because you want AI on your support queue, eesel gives you that without a token bill to watch. The AI helpdesk teammate plugs into the helpdesk you already use, like Zendesk or Freshdesk, learns from your past tickets and help center, and runs on a fixed monthly plan. Before it answers a live customer, you can run it against your historical tickets and read every reply.

Developers can drive the same setup from the eesel CLI: an AI coding agent like Claude Code or Codex can upload approved knowledge such as exported help articles and macros, ask the agent test questions, and check the answers before anything goes live. Connecting the helpdesk itself still needs someone with admin access to approve it.
You can try eesel free on a slice of your queue, see plans and pricing, or compare it with using ChatGPT directly if you're still deciding whether to build it yourself.