GPT-6.2 Astra and Sol: New OpenAI Models, Student-Friendly Prices
OpenAI launched GPT-6.2 Astra at $8 per million input tokens, down 20% from its predecessor. The smaller Sol model costs just $2 and meets most student needs — here's how to decide which to use.
OpenAI's own API docs page for GPT-6.2 Astra, which I opened on 17 November 2026, lists the price as $8 per million input tokens and $40 per million output tokens. The previous flagship, GPT-6 Astra, cost $10 and $50. A smaller model next to it, GPT-6.2 Sol, costs $2 and $10. Which one should a student pay for?
For most student projects, use GPT-6.2 Sol and switch to GPT-6.2 Astra only for hard problems. Sol's tokens cost a quarter of Astra's. Cost per task also depends on how many tokens a model uses, so the two figures differ. On the Artificial Analysis Intelligence Index, Sol scores 57 and Astra scores 62. That is a real gap. On FrontierCode 2.0, a coding benchmark, Sol trails Astra by just 0.5 points (the-decoder). Sol's 57 is the level the old Astra reached, at about 15% of the cost per task (the-decoder). For the main rival, see the Claude Fable 5.2 price and speed breakdown.
What OpenAI launched: GPT-6.2 Astra and Sol
OpenAI released two models on 17 November 2026: Astra, the flagship, and Sol, the cheaper everyday model, with API IDs gpt-6.2-astra and gpt-6.2-sol (OpenAI API docs). Prices and model IDs come from OpenAI's docs and OpenRouter. Benchmarks and Edu availability come from news reports, so treat them as less certain.
Astra reads text and images. Its context window holds 1.05 million tokens, and one reply can be up to 128K tokens long (OpenAI docs). A context window is how much text the model can see at once. That is enough to paste in a whole small codebase.
API prices per million tokens
Astra's price dropped 20% and its cached input price dropped 60% to $0.40, while Sol's price did not change (the-decoder). A token is a small piece of a word, so a million tokens is far more text than most student apps send in a day.
| Model | Input | Cached input | Output | Source |
|---|---|---|---|---|
| GPT-6.2 Astra | $8 | $0.40 | $40 | OpenRouter |
| GPT-6 Astra (old) | $10 | $1.00 | $50 | the-decoder |
| GPT-6.2 Sol | $2 | $0.10 | $10 | OpenRouter |
None of the sources give a rupee price. For a worked example, take 100 requests of 2,000 input and 500 output tokens each, which is 0.2 million input and 0.05 million output tokens. At the Sol prices that costs $0.90, and at the Astra prices it costs $3.60. Indian readers paying by card will see the dollar amount converted by their bank, so multiply the dollar cost by your bank's rate on the day to get the rupee figure.
Where Astra and Sol rank on benchmarks
Astra is second on the Artificial Analysis Intelligence Index at 62, behind Claude Fable 5.2 at 65, and it is first in 3D design (the-decoder). Sol scores 57 on the same index, five points below Astra, which is a different measure from the 0.5-point FrontierCode gap below. Fable 5.2 is the main rival, so if you are weighing the two, read the Claude Fable 5.2 price and speed breakdown for what it costs and how fast it answers.
The 3D design test is called AA-3D. Models build 3D scenes, and people vote on the better result. Each model gets an Elo score, the same rating system chess uses.
| Model | AA-3D Elo (the-decoder) |
|---|---|
| GPT-6.2 Astra | 1,318 |
| Claude Fable 5.2 | 1,271 |
| GPT-6.2 Sol | 1,259 |
Scores from TestingCatalog and the-decoder.
On FrontierCode 2.0, a coding benchmark, Sol trails Astra by just 0.5 points at about one-fifth of the cost (the-decoder). Google's latest model is the other one to compare; see the Gemini 4 Hydrogen price post.
A student's-eye read: Sol for daily work, Astra for hard projects
For a student on a budget, the gap between Sol and Astra is small enough that Astra is worth paying for only when a project is hard. Most of what students send to a model is routine work, and routine work does not need the flagship.
Say you are building a small expense-tracker web app with an API budget of a few dollars. You ask the model for form validation, CSS fixes and unit tests. Sol handles that kind of request well, and each call costs a quarter of Astra's.
Then a bug appears that spans several files, and Sol keeps suggesting the same wrong fix. That is the moment to send one request to Astra. The same goes for agent tasks, where the model plans and runs several steps on its own.
Agent work is where Astra improved most. On Agents' Last Exam, it gains 5.2 points over old Astra at under a third of the cost (TestingCatalog). If you want your app to pick the model for you, a small router does the job; the routing classifier walkthrough shows the idea with Gemini, and it carries over to OpenAI.
Pros
- Sol as your default keeps a small budget alive for the whole semester.
- Astra on demand gives you the stronger model only where it changes the result.
Cons
- You must notice when Sol is stuck, which takes some practice.
- Two models mean two sets of quirks to learn.
Edu users get both models in ChatGPT Work and Codex
Only Crypto Briefing reports this Edu availability, so check your own plan's page before you rely on it. It says Plus, Pro, Enterprise and Edu users get both models inside ChatGPT Work and Codex, so a student on an Edu plan would have nothing extra to set up (Crypto Briefing). Codex is OpenAI's coding agent, so Edu students could try both models on real code without an API key. For most students, the verified API prices above are the real saving.
Higher tiers also get a faster mode. Pro 500 users get Ultrafast for both models, and Pro 200 users get Ultrafast starting with Sol (TestingCatalog).
Ask your college IT desk or computer science department whether it has a ChatGPT Edu plan. Colleges in India and the US both buy these, and a student account costs you nothing.
Switch models in the API or OpenRouter
Changing models in your own code takes one line: replace the model string with gpt-6.2-sol or gpt-6.2-astra. Here is a minimal chat request. It runs in Node 18 or newer, and if you get a 404 error, check the model ID against the docs:
const res = await fetch("https://api.openai.com/v1/chat/completions", {
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
},
body: JSON.stringify({
model: "gpt-6.2-sol",
// model: "gpt-6.2-astra", // swap in for hard problems
messages: [{ role: "user", content: "Write a test for my addExpense function." }],
}),
});
const data = await res.json();
console.log(data.choices[0].message.content);
On OpenRouter, the slugs are openai/gpt-6.2-sol and openai/gpt-6.2-astra (OpenRouter).
The cached rates in the price table apply when you resend the same long start of a prompt. A long system prompt or a pasted codebase is the usual case. Keep that part identical across calls and put the changing question at the end.
Caveats before you switch
Coding gains were flat on the Coding Agent Index. On the hardest factual questions, both models still make up answers about 55-59% of the time, which is not the rate for everyday questions (the-decoder). A cheaper price does not mean better code than last week.
Treat every factual claim as a draft until you check it against docs. Run your own tests on generated code before you commit it.
Should you switch to GPT-6.2 Sol?
Yes if you pay for API calls: try Sol first on your current project, and keep your old model only if Sol fails on your own tests. The Artificial Analysis leaderboard gives a starting point, but your project is the test that counts.
- Edu plan user: nothing to buy. Use Sol in Codex and open Astra when you get stuck.
- API-budget builder: make Sol your default model string and route only hard tasks to Astra.
- Free tier user: these models need a paid or Edu plan. The Qwen 4 Max post covers open-weight models you can run instead.
Pick five tasks
Choose five real tasks from your current project and run each one on Sol.
Note the failures
Mark every answer that is wrong, breaks a test, or misses the point.
Rerun failures on Astra
Send only the failed tasks to Astra with the same prompt.
Keep the cheaper model that passes
If Sol passed a task type, use Sol for it from now on.
Run the same five tasks from your current project on gpt-6.2-sol today, note which ones fail, and rerun only those on gpt-6.2-astra.