Skip to main content
DevHivesBlog

Search the blog

Find a post by title, tag or topic

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.

Arnab Biswas7 min read
WhatsApp
Two OpenAI logos side by side representing the two new models, GPT-6.2 Astra and Sol.

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.

Watch: GPT-6.2 Astra and GPT-6.2 Sol: Models built for the real world, OpenAI (YouTube)

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.

ModelInputCached inputOutputSource
GPT-6.2 Astra$8$0.40$40OpenRouter
GPT-6 Astra (old)$10$1.00$50the-decoder
GPT-6.2 Sol$2$0.10$10OpenRouter

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.

GPT-6.2 Astra leads 3D design, and Sol is not far behind Claude Fable 5.2
GPT-6.2 Astra leads 3D design, and Sol is not far behind Claude Fable 5.2

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.

ModelAA-3D Elo (the-decoder)
GPT-6.2 Astra1,318
Claude Fable 5.21,271
GPT-6.2 Sol1,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.
  1. Pick five tasks

    Choose five real tasks from your current project and run each one on Sol.

  2. Note the failures

    Mark every answer that is wrong, breaks a test, or misses the point.

  3. Rerun failures on Astra

    Send only the failed tasks to Astra with the same prompt.

  4. 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.

ShareWhatsAppLinkedInX

Picked from the tags and topic of this post.

A sparkle representing an AI agent next to a hand-written bracket representing code, standing for the ChatGPT Wallet that lets agents pay while your card number stays hidden.
ai6 min read

ChatGPT Wallet Lets AI Agents Pay With Your Card, Not Your Card Number

OpenAI's new ChatGPT Wallet gives Dots agents a payment layer that can buy things for you, without sharing your real card number with merchants. It launched on November 13, 2026, but only for US Pro subscribers. Every purchase still needs your approval via Face ID or a fingerprint.

Arnab Biswas
Anthropic logo twice, symbolizing the new model versus the old, cutting costs.
ai6 min read

Claude Fable 5.2: New Model Cuts Coding Costs 20% for Students

Anthropic launched Claude Fable 5.2 today, and it's the cheapest top-tier coding model yet at $8 in and $40 out per million tokens. Here's what that means for a student budget, plus four projects you can build free during launch week.

Arnab Biswas