On September 29, 2026, OpenAI used its DevDay keynote to announce GPT-6.1 Sol, a model that sits just below the company's flagship Astra model but costs one-fifth as much per API call. For anyone building apps, writing code with AI assistance, or just trying to pick the right model without overspending, this launch matters because the price gap between "best available" and "good enough" just got dramatically wider.
GPT-6.1 Sol is OpenAI's newest mid-tier model, delivering near-Astra quality for coding and professional work at one-fifth the API price.
If you are new to this landscape: OpenAI sells access to its AI models through an API (application programming interface), which is a way for your code to send text to OpenAI's servers and get responses back. You pay based on "tokens," which are chunks of text roughly three to four characters long. Different models charge different rates per million tokens. Astra is OpenAI's top model in the GPT-6 family, the one you pick when you need the absolute best results. Sol sits one tier below it. Luna sits below Sol as the budget option. If you want the full background on where Astra fits, our GPT-6 Astra beginner explainer covers the flagship model in detail.
What is GPT-6.1 Sol and how does it differ from the older GPT-6 Sol?
The ".1" in GPT-6.1 Sol signals a refresh, not a brand-new architecture. OpenAI introduced the model as delivering "near-Astra intelligence for coding, computer use, and professional work" at a fraction of Astra's standard API prices. The key word is "near." This is not Astra. It is close enough that for many tasks you will not notice the difference, and for the tasks where you would, the cost savings may still be worth the trade.
The API documentation lists a 1,050,000-token context window, which means the model can read and reason over roughly 800,000 words of text in a single request. That is about 3,000 pages of material. It can produce up to 128,000 output tokens in a single response, which is roughly 96,000 words. The knowledge cutoff, the date beyond which the model has no training data, is April 30, 2026. These specifications match the pre-refresh GPT-6 Sol, which suggests the update focused on quality improvements rather than expanded capacity.
Simon Willison, a developer and commentator known for thorough AI model testing, ran his informal pelican test on GPT-6.1 Sol during DevDay. The test asks the model to draw a pelican riding a bicycle using SVG, which is a vector graphics format that code can render as an image. His verdict: the outputs are "not notably different from the GPT-6 family pelicans." In other words, the visual quality did not regress. This is a low bar but a useful smoke test. If the model could still handle a creative, multi-step drawing task after the refresh, it had not lost capabilities in the update.
How much cheaper is Sol compared to Astra?
The pricing difference is the entire story here. OpenAI's API documentation lists GPT-6.1 Sol at $2.00 per million input tokens and $10.00 per million output tokens. Astra costs $10.00 per million input tokens and $50.00 per million output tokens. That is a clean five-to-one ratio on both input and output. Luna, the budget tier, costs $0.10 per million input tokens and $0.50 per million output tokens.
The chart above shows the three tiers side by side. Sol occupies the middle ground: five times cheaper than Astra, twenty times more expensive than Luna.
There are nuances that affect your real-world bill. If your prompt exceeds 272,000 input tokens, the pricing doubles for input and cache rates and increases by 1.5 times for output, applied to the entire request. This discourages stuffing enormous documents into a single call. On the flip side, cached input tokens, which are portions of your prompt that OpenAI has seen before and can reuse, cost only $0.10 per million tokens, which is 5 percent of the standard input rate. If your app sends the same system instructions or reference documents with every request, caching brings your effective input cost close to zero.
Batch and Flex processing modes cut the standard price in half, to roughly $1.00 per million input tokens and $5.00 per million output tokens, but responses come back slower. Fast mode doubles the price for quicker responses. Regional processing, available for US and EU data residency, adds a 10 percent premium.
For a concrete sense of what this means per individual request, Simon Willison's comparison data tracks the cost of generating an SVG pelican at different reasoning effort levels. Reasoning effort controls how much internal thinking the model does before answering: more thinking produces better results but consumes more output tokens. At "max" effort, Astra costs 63.21 cents per request while Sol costs 18.23 cents. At "medium" effort, which is the default, Astra costs 12.82 cents and Sol costs 2.69 cents. At "low" effort, Astra costs 9.55 cents and Sol costs 0.82 cents.
The chart above shows that the cost gap between Astra and Sol widens as reasoning effort increases. At low effort, Sol is about 12 times cheaper. At max effort, Sol is about 3.5 times cheaper. The ratio shifts because Sol generates more output tokens at higher effort levels, which narrows the per-token advantage somewhat, but the absolute savings are still large.
What can GPT-6.1 Sol actually do for you?
The model supports a broad set of capabilities through OpenAI's Responses API. For beginners, here is what each one means in plain terms:
- Function calling: your code can ask the model to decide which function (a named block of code) to run based on what the user said, then call it. This is the foundation of AI agents.
- Structured outputs: the model can format its response as JSON, which is a structured data format that code can parse directly, instead of free-form text.
- File search: the model can search through documents you upload to find relevant information.
- Code interpreter: the model can write and run Python code to answer questions that require calculation or data analysis.
- Computer use: the model can control a computer interface, clicking buttons and typing text, similar to how a human would operate a desktop.
- MCP (Model Context Protocol): a standard way for the model to connect to external tools and data sources. Our beginner's guide to MCP covers what it adds beyond a normal API.
- Apply patch: the model can modify existing code files by generating and applying patches, which are targeted edits to specific lines.
One notable limitation: fine-tuning is not supported. Fine-tuning means training the model further on your own data to specialize it for a specific task. If that is part of your workflow, Sol is not the right pick. You would need Astra or an older model that supports it.
The model accepts text and images as input but produces only text as output. It cannot generate images directly, though it can use the image generation tool through the Responses API. Reasoning effort levels support five settings: low, medium (the default), high, xhigh, and max. The "none" and "minimal" settings that some older models offered are not available on Sol, which means you cannot fully disable the model's internal thinking process.
When should you pick Sol over Astra or Luna?
The decision tree is straightforward. Pick Astra when the cost of a wrong or mediocre answer is high: legal analysis, medical reasoning, complex multi-step agent workflows where one error cascades into many failures. Pick Luna when the task is simple and volume is high: classification, summarization, basic chatbot responses. Pick Sol for everything in between.
For coding specifically, Sol is positioned as the sweet spot. Most programming tasks, from writing functions to debugging to explaining code, do not require Astra-level reasoning. They require competence, reliability, and enough context to understand your codebase. Sol delivers that at a price that lets you run it on every commit, every pull request, every question a developer asks, without watching your API bill climb.
If you are already using GPT-6 Sol, the pre-refresh version, switching to 6.1 is a model name change in your API call: use gpt-6.1-sol instead of gpt-6-sol. The pricing and rate limit structure remain the same. If you are coming from GPT-5.6 Sol, which the same comparison data shows at $4.00 per million input tokens and $20.00 per million output tokens, switching to 6.1 Sol halves your cost while giving you a newer, more capable model. Our earlier explainer on the GPT-5.6 model lineup covers the older generation if you need context on where these tiers came from.
Rate limits scale with your spending tier. Tier 1 allows 500 requests per minute and 500,000 tokens per minute. Tier 5 allows 15,000 requests per minute and 40,000,000 tokens per minute. The Free tier does not support Sol at all, so you need a paid API account to use it.
What "near-Astra" actually costs you
OpenAI's framing, "near-Astra intelligence," is doing heavy lifting in that sentence. "Near" means you give something up. You give up some accuracy on the hardest problems, some nuance in edge cases, some reliability when the task sits at the absolute frontier of what current AI can do. What you get back is a model that costs 80 percent less and is good enough for the vast majority of real work. The bet OpenAI is making is that most developers and businesses do not actually need the absolute best model. They need a model that is good enough, cheap enough to run at scale, and reliable enough to ship with. GPT-6.1 Sol is that model. Whether "near" is good enough for your specific task is something you can only answer by running the comparison yourself, and at these prices, running that comparison costs less than a cup of coffee.
Sources
- openai.com: Introducing GPT-6.1 Sol
- developers.openai.com: GPT-6.1 Sol Model API documentation
- simonwillison.net: GPT 6.1 Sol pelican test and commentary
- static.simonwillison.net: GPT-6 and GPT-5.6 SVG reasoning-effort comparison data
