
GPT-6.2 Sol costs $2 per million input tokens, $0.10 cached, and $10 output, exactly what GPT-6.1 Sol cost. Per hard task it's about 20% cheaper, because it uses fewer tokens. But a straight model swap can cost more in two places. In my test, GPT-6.2 Sol cached nothing from the top-level instructions field while 6.1 Sol did, which turns $5.45 per 1,000 support tickets into $29.20. And there's no Flex tier, so jobs that ran on 6.1 Sol Flex now pay 20% to 100% more unless they move to the Batch API.
How much does GPT-6.2 Sol cost?
GPT-6.2 Sol costs $2 per million input tokens and $10 per million output tokens at the Standard tier, with cached input at $0.10. OpenAI released it on 17 November 2026 alongside GPT-6.2 Astra, and the launch post says it "carries forward GPT‑6.1 Sol's rates." If you want the model itself, the GPT-6.2 Sol overview covers what changed and how it benchmarks.
If you're pricing it for a support queue, an AI helpdesk teammate like eesel skips the token meter, and with the eesel CLI a coding agent can upload approved help articles and run test questions against them before anything goes live. Connecting the helpdesk itself still needs an admin to approve it.

I spend a lot of my week on how people search for model prices, and the query behind "GPT-6.2 Sol pricing" is nearly always the same: is the upgrade going to change my bill? So I priced it the way eesel prices a support agent, per ticket, and ran my own caching test on both Sol versions. Here's every meter from OpenAI's pricing page and the GPT-6.2 Sol model page, per million tokens:
| Tier | Input | Cached input | 30-min cache write | 12-hour cache write | Output |
|---|---|---|---|---|---|
| Standard | $2.00 | $0.10 | $2.50 | $5.00 | $10.00 |
| Standard, over 272K input | $4.00 | $0.20 | n/a | n/a | $15.00 |
| Batch | $1.00 | $0.05 | $1.25 | $2.50 | $5.00 |
| Background, 8-hour window | $1.20 | $0.06 | $1.50 | $3.00 | $6.00 |
| Background, 2-hour window | $1.40 | $0.07 | $1.75 | $3.50 | $7.00 |
| Fast | $4.00 | $0.20 | $5.00 | $10.00 | $20.00 |
| Ultrafast (to 28 Feb 2027) | $6.00 | $0.30 | $7.50 | $15.00 | $30.00 |
| Ultrafast (from 1 Mar 2027) | $12.00 | $0.60 | $15.00 | $30.00 | $60.00 |
| Flex | Not offered |
The background rows are my arithmetic on OpenAI's rule that eligible background requests run "30% below Standard for the 2‑hour completion window and 40% below Standard for the 8‑hour completion window." The long-context row comes from the model page: 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.
The model has a 1,050,000-token context window, 922,000 max input tokens, 128,000 max output tokens, and a 1 June 2026 knowledge cutoff. The API also "rejects requests that set reasoning effort to none," so low is the cheapest setting you can pick. Regional data residency endpoints add 10%, as they do for every model released after 5 March 2026.
What exactly are you billed for?
Each GPT-6.2 Sol request lands on up to four meters, and they're priced very differently:
- Fresh input at $2 per million: the customer's message and anything else that changed.
- Cached input at $0.10 per million: the part at the start of the prompt that matches a recent request exactly.
- Cache writes at $2.50 (30 minutes) or $5 (12 hours) per million: the first time a reusable prefix gets saved.
- Output at $10 per million: the reply plus any hidden reasoning tokens, which OpenAI's reasoning guide bills as output.
OpenAI's prompt caching guide says cache writes are "not an additive fee": each input token bills once, at one of the three input rates. Reads on GPT-6.2 Sol cost "0.05× the ordinary input rate," a 95% discount, where most other recent OpenAI models get 90%. The minimum cacheable prefix is 1,024 tokens.
That makes a cached token a twentieth of the price of a fresh one. On any app that sends the same instructions or knowledge with every call, the cache hit rate matters more than the sticker. That's why the next result surprised me.
Does GPT-6.2 Sol actually cache your prompt?
Only if the prompt is in the right place. I tested it on 18 November 2026 through the Responses API: an 8,300-token help center for a fictional SaaS company, three different customer questions in a row, low effort, run twice on both Sol models. The only variable was where the help center sat.
| Model | Prompt location | Call 1 | Calls 2 and 3 |
|---|---|---|---|
| GPT-6.1 Sol | Top-level instructions | 8,295 tokens written to cache | 8,283 tokens read from cache |
| GPT-6.1 Sol | Developer message | 8,295 written | 8,283 read |
| GPT-6.2 Sol | Top-level instructions | 0 written | 0 read |
| GPT-6.2 Sol | Developer message | 8,295 written | 8,283 read |
Both runs gave identical numbers. So the same code that cached perfectly on GPT-6.1 Sol stops caching the moment you change the model ID to gpt-6.2-sol, and nothing errors. You just pay $2 per million on every prompt token instead of $0.10. eesel's launch-day test on GPT-6.2 Astra showed the same behavior, so it looks like a 6.2-generation change rather than a Sol quirk.
OpenAI's docs point the same way without saying it outright. The caching guide notes that "top-level instructions cannot contain an explicit breakpoint" and that 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."
Here's what that does to a support agent that reuses a 12,500-token prompt (instructions plus help center content) with 600 tokens of new input and 300 tokens of output per ticket:

That's a 5.4x jump per ticket from a model upgrade that was supposed to be price-neutral. The fix is a few lines: move the prompt into a developer message, then check cached_tokens in the usage block of your first few calls. If you migrated straight from GPT-5.6 Sol or earlier, OpenAI's migration guide also says to replace prompt_cache_retention with prompt_cache_options.ttl.
What happened to Flex pricing?
GPT-6.2 Sol doesn't have it. OpenAI's Flex table lists GPT-6.1 Sol at $1/$5, along with GPT-6 Astra, GPT-6.1 Terra, and GPT-6 Luna, but no 6.2 Sol row:

Developers noticed within hours of launch:
"Did they remove the flex pricing? I see it here:- https://developers.openai.com/api/docs/models/gpt-6.1-sol but not here:- https://developers.openai.com/api/docs/models/gpt-6.2-sol"
Flex mattered because it priced tokens "at Batch API rates," per OpenAI's Flex guide, while still answering a normal API call, just slower and with "occasional resource unavailability." It suited evals, data enrichment, and overnight jobs. On GPT-6.2 Sol, those jobs have three discount routes, each with a catch:
- Batch API (50% off). Same price as old Flex, but you submit a file and collect results later, so the code changes.
- Background, 8-hour window (40% off). One flag on a normal Responses call, but 20% more than Flex.
- Background, 2-hour window (30% off). Faster turnaround, 40% more than Flex.
Per OpenAI's background guide, the discounted windows are in public beta, require Standard processing, and share the Batch rate limit. There's also a caching catch: "Standard requests outside the discounted completion windows can't reuse prompt cache entries created by 2h or 8h background requests, even when the prompt is identical." So you can't warm a cache overnight and read it cheaply from your live app.
Here's one overnight job, tagging 50,000 old tickets at about 2,000 input tokens and 200 output tokens each:

If a job like that runs every night, the gap between Batch and Standard is $4,500 a month. For pure tagging or triage, a smaller model may be the better saving: GPT-6.1 Terra still has Flex at $0.50/$2.50, and GPT-6 Luna goes lower still.
Is GPT-6.2 Sol cheaper per task than GPT-6.1 Sol?
On long, hard work, yes, by about 20%. On short replies, it's a hair more expensive. Both are true, and which one you feel depends on how much the model has to think.
Artificial Analysis puts the cost of running its Intelligence Index at $1.01 per task for GPT-6.2 Sol against $1.27 for GPT-6.1 Sol at max effort, with a score of 57 against 55. Same rates, fewer tokens: Artificial Analysis counted 60.9 million output tokens for 6.2 Sol at max against 63.7 million for 6.1 Sol. It also places 6.2 Sol "on par with GPT-6 Astra at ~15% of the Cost per Task."
Short support replies tell a different story. In eesel's 60-run ticket test for the GPT-6.2 Sol review, with 15 tickets at low and medium effort on both models, every setup passed all 15:
| Setup | Cost per 1,000 tickets | Avg. output tokens |
|---|---|---|
| GPT-6.2 Sol, medium | $1.42 | 60 |
| GPT-6.2 Sol, low | $1.41 | 58 |
| GPT-6.1 Sol, medium | $1.35 | 55 |
| GPT-6.1 Sol, low | $1.32 | 52 |
GPT-6.2 Sol wrote slightly longer replies, and at the same price per token, that accounts for most of the 5% to 7% difference. Those tickets used a short prompt with no help center in it, which is why they're so cheap next to the 12,500-token example above.
On Hacker News, one developer reading OpenAI's charts landed in the same place on the effort trade:
"Looks like 6.1-sol high+ is equivalent to 6.2-sol medium at the same price. So a bit smarter at a cheaper cost."
Which reasoning effort should you pay for?
For most apps, medium. Reasoning tokens bill as output at $10 per million, so effort is a price setting as much as a quality one. Artificial Analysis counted these output tokens across its full Intelligence Index for GPT-6.2 Sol:
| Effort | AA Intelligence Index | Output tokens to run the index | Output vs max |
|---|---|---|---|
| Low | 41 | 7.2M | 12% |
| Medium | 53 | 14.6M | 24% |
| High | 55 | 22.7M | 37% |
| Xhigh | 56 | 33.3M | 55% |
| Max | 57 | 60.9M | 100% |
Medium keeps 53 of max's 57 points on a quarter of the output tokens. Going from xhigh to max nearly doubles output for one point. OpenAI's migration guide also recommends starting new integrations at medium.
On short tasks like support replies, the setting barely registers. The low and medium runs in that ticket test cost $1.41 and $1.42 per 1,000 tickets because the model reasons very little before a three-sentence answer either way. Spend your tuning time on the cache, not on effort, unless your agent runs long multi-step jobs.
What would GPT-6.2 Sol cost for your volume?
Plug your own numbers into the calculator. It compares GPT-6.2 Sol with GPT-6.1 Sol and GPT-6.2 Astra on the same workload, using OpenAI's published rates. Cache misses are billed as 30-minute cache writes. The prompt location switch applies what I saw in my test: on the 6.2 models, a prompt in the top-level instructions field is billed as fresh input every time.
At the defaults, 8,000 requests a month with a 95% cache hit rate cost $55.60 on GPT-6.2 Sol. Flip the prompt location to the instructions field and the same month costs $233.60, while GPT-6.1 Sol stays at $55.60. Switch the tier to a background window and you'll see the Flex gap from the last section.
What does GPT-6.2 Sol cost at different team sizes?
Here's the 12,500-token support workload at three monthly volumes, on Standard rates. The middle column assumes the prompt is in a developer message with a 95% hit rate; the third shows what happens when it's in the instructions field.
| Monthly tickets | GPT-6.2 Sol, cached | GPT-6.2 Sol, instructions field | GPT-6.2 Sol, Batch | GPT-6.2 Astra, cached |
|---|---|---|---|---|
| 1,000 | $6.95 | $29.20 | $3.48 | $27.80 |
| 8,000 | $55.60 | $233.60 | $27.80 | $222.40 |
| 50,000 | $347.50 | $1,460.00 | $173.75 | $1,390.00 |
Batch only fits work nobody is waiting on, like drafting summaries of last week's tickets. Live replies stay on Standard. The GPT-6.2 Astra pricing breakdown shows why Astra is four times the cost on the same workload.
For a sense of scale, MentorShow, a French online learning platform, told eesel it receives between 5,000 and 13,000 tickets a month. Its eesel agent reads each new HubSpot conversation, checks the member's record and a knowledge base of 123 articles, and leaves an internal note with a draft reply in the member's language. At that volume, GPT-6.2 Sol tokens with a working cache come to roughly $35 to $90 a month. With the instructions-field bug, $146 to $380.
Either way, the tokens are the small line in AI customer service cost. The bigger lines are retrieval, function calling for order lookups, escalation rules, and the observability to see what the agent said.
That's why the cost of an AI support agent depends more on build versus buy than on the model.
Is GPT-6.2 Sol cheaper than Claude Sonnet 5.5?
On the sticker they're identical. Anthropic's pricing page lists Claude Sonnet 5.5 at $2 input, $10 output, and $0.10 cache reads per million tokens. The differences are in the fine print:
| Per million tokens | GPT-6.2 Sol | Claude Sonnet 5.5 | GPT-6.2 Astra | Claude Opus 5.5 |
|---|---|---|---|---|
| Input | $2.00 | $2.00 | $8.00 | $4.00 |
| Output | $10.00 | $10.00 | $40.00 | $20.00 |
| Cache read | $0.10 | $0.10 | $0.40 | $0.20 |
| Cheapest cache write | $2.50 (30 min) | $2.50 (5 min) | $10.00 (30 min) | $5.00 (5 min) |
| Longer cache write | $5.00 (12 hours) | $4.00 (1 hour) | $20.00 (12 hours) | $8.00 (1 hour) |
| Prompts over 272K | 2x input, 1.5x output | Same rate to 1M | 2x input, 1.5x output | Same rate to 1M |
| Batch | 50% off | 50% off | 50% off | 50% off |
Three things decide which is cheaper for you:
- Quiet queues favor Sol. The same $2.50 write buys 30 minutes on Sol and 5 minutes on Sonnet. If requests arrive 10 minutes apart, Sol keeps its cache warm and Sonnet keeps rewriting it.
- Huge prompts favor Sonnet. Anthropic charges "the same per-token rate" across the full 1M window. A 400,000-token request with a 4,000-token answer costs $1.66 on GPT-6.2 Sol and $0.84 on Sonnet 5.5. Splitting documents under 272K closes most of that gap.
- Token count per task decides the rest. Equal rates mean the model that answers in fewer tokens wins. That's workload-specific, so test both on your own prompts.
If you're shopping wider, Claude Opus 5.5 costs twice as much per token, and best AI model for support compares the field on ticket work.
What does GPT-6.2 Sol cost in ChatGPT?
In ChatGPT you pay a flat subscription, not per token. OpenAI says GPT-6.2 Sol is "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 Sol 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 the Codex app |
| Pro (Pro 100, Pro 200, Pro 500) | From $100/month | Yes; Pro 200 gets Ultrafast with Sol for the first time, and Pro 500 gets Ultrafast with Sol or Astra |
| Enterprise and Edu | Contact sales | Yes, once an admin enables it |
Prices come from ChatGPT's pricing page. Pro plans also include monthly API credits: $100, $200, or $500 depending on the tier, subject to OpenAI's eligibility terms. At the cached rate of $6.95 per 1,000 tickets, $200 of credits covers about 28,800 GPT-6.2 Sol tickets a month. The ChatGPT pricing guide has the full plan breakdown.
Is GPT-6.2 Sol worth it for customer support?
On price, yes. It's a quarter of GPT-6.2 Astra's token cost and passed all 15 tickets in eesel's test. The real risks are elsewhere. Artificial Analysis measured a 55% hallucination rate for Sol at max effort, meaning it guesses rather than admits it doesn't know. In that test it turned a tracking number into a ups.com link the order tool never supplied. A cheap model that guesses still needs grounding, hallucination prevention, and testing on real tickets before it answers customers.
There's also the question of whether you want a token bill at all. This one can move without your code changing: the cache stops hitting after an upgrade, a discount tier disappears, or Ultrafast doubles on 1 March 2027. On one eesel sales call, a budget-conscious buyer told the team a previous vendor's price had more than doubled, and asked for a contractual price lock before signing anything. Token pricing can't offer that.
That's the build vs buy trade. Build on GPT-6.2 Sol and you get cheap tokens, plus the job of watching cached_tokens, tiers, and pricing pages. Buy, and the model choice and its billing quirks become someone else's problem.
Try eesel
If you're pricing GPT-6.2 Sol because you want AI on your support queue, eesel's AI helpdesk teammate gives you that without a token meter. It plugs into the helpdesk you already use, learns from your past tickets and help center, and lets you run it against historical tickets so you can read every answer before it touches a live customer. Plans are fixed credit bundles, starting at $299 for 500 credits, so a caching change or a new tier at OpenAI doesn't show up on your bill.
Lesson Pro, a group of private lesson brands, runs it across two Zendesk accounts: in one month it worked 1,900 tickets, left 1,700 internal notes for the team, and drafted 560 replies for a person to approve, answering from about 4,000 tickets, articles, and web pages.

You can try eesel free on a slice of your queue, or compare it with using ChatGPT directly if you're still weighing the build route.
Frequently Asked Questions
How much does GPT-6.2 Sol cost?
Is GPT-6.2 Sol more expensive than GPT-6.1 Sol?
Does GPT-6.2 Sol have Flex pricing?
How do I get the GPT-6.2 Sol cached input discount?
cached_tokens in the usage block of the Responses API to confirm.