GPT-6.1 Sol API Pricing: A Practical Model Selection Test

OpenAI released GPT-6.1 Sol on September 29, 2026 as a lower-cost option for complex coding, computer use and professional work. The practical takeaway is not that every workload should switch. It is that teams now have a stronger reason to test Sol as the working default, then reserve GPT-6 Astra for tasks where measured quality gains justify the higher complete-task cost.

OpenAI lists standard GPT-6.1 Sol pricing at $2 per million input tokens, $0.10 per million cached input tokens, $2.50 per million cache-write tokens and $10 per million output tokens. GPT-6 Astra is listed at $10, $1, $12.50 and $50 respectively. Those are token rates, not a prediction of your final bill. Tool calls, long-context pricing, retries, reasoning effort, regional processing and human review can materially change the cost of completing a task.

This article gives you a controlled five-step test for deciding where GPT-6.1 Sol belongs in your model routing.

What OpenAI announced

OpenAI describes GPT-6.1 Sol as delivering near-Astra performance at a lower cost for complex work. Its model page lists a 1,050,000-token context window, up to 128,000 output tokens, text and image input, and support for tools including web search, file search, computer use, hosted shell and MCP through the Responses API.

For tool calling, OpenAI explicitly directs developers to the Responses API. Chat Completions remains available without tool calling. Supported reasoning settings are low, medium, high, xhigh and max. The model does not support none or minimal reasoning effort.

Axios independently reported the GPT-6.1 Sol launch as one of the major announcements from OpenAI's September 29 DevDay. The news is recent. The performance decision still belongs to your own evaluation set.

GPT-6.1 Sol API pricing at a glance

Prices were verified against OpenAI's model pages on October 1, 2026. OpenAI notes that prompts above 272,000 input tokens use higher rates for the full request. Fast, Batch, Flex and regional processing can also change rates. Verify current pricing before making a procurement or routing decision.

The headline comparison is useful, but it is incomplete. A model that costs less per token can cost more per accepted result if it needs repeated attempts, produces longer outputs or creates more review work. A more expensive model can also be wasteful when the task is well-scoped and the cheaper option already clears the acceptance bar.

The five-step model selection test

1. Define one repeatable task

Avoid testing with a vague prompt such as "build something impressive." Choose a task that resembles real production work and can be repeated. Examples include:

• repair a known bug and pass the existing test suite
• extract a fixed schema from a representative document set
• complete a browser workflow in a sandbox account
• produce a client-ready brief from the same source packet

Write down the allowed tools, maximum run time, required output format and conditions that trigger human review. Remove secrets and use safe test data.

2. Create an acceptance rubric before running models

Score the result, not the model's reputation. A compact rubric can cover:

Set a pass threshold before you see the outputs. For high-impact tasks, include mandatory conditions that cannot be offset by a strong total score.

3. Run matched trials

Use the same inputs, tool permissions, environment and acceptance rubric. Start GPT-6.1 Sol at the reasoning effort that fits the task. OpenAI currently lists medium as the default. Compare it with Astra only on representative tasks, not on a single showcase prompt.

Run enough cases to expose ordinary variation. Record failures as evidence rather than quietly retrying until a model succeeds. If a run needs intervention, log that intervention as part of the task cost.

4. Calculate complete-task cost

Use this model:

complete-task cost = token cost + tool fees + retry cost + review cost + failure impact

Token cost is the easiest component to see. The others often determine the production choice.

For example, imagine a hypothetical document workflow where both models pass the same acceptance bar. If Sol needs no additional retry or review, the lower token rate is meaningful. If Sol creates an extra 12 minutes of review on every run while Astra does not, the labor difference may outweigh the token savings. These numbers are illustrative, not a benchmark or expected outcome.

5. Choose a default and define an escalation rule

A useful routing policy is explicit:

• Use GPT-6.1 Sol when it consistently clears the acceptance bar for complex, reviewable work.
• Escalate to Astra when the task is unusually ambiguous, the cost of an error is high, or matched tests show a meaningful quality advantage.
• Use a more efficient model for scoped, high-volume work when it passes the same rubric.
• Require human approval for legal, safety, financial, account-access or irreversible actions regardless of model.

This is a gate, not a permanent verdict. Re-run the evaluation when prompts, tools, models or source data change.

A small example: repository change routing

Consider a software team evaluating a recurring maintenance task. The model must update one dependency, adjust affected code, run tests and prepare a concise change note. The repository is a sandbox copy, and merge permission remains with a human.

The team defines five mandatory conditions: the project builds, relevant tests pass, no unrelated files change, the change note names the risk, and the model does not bypass a failing check. It then runs the same set of representative tasks with Sol and Astra.

The decision is based on accepted patches per dollar and reviewer time per accepted patch. If Sol clears the same gate with comparable review effort, it becomes the default for that lane. If a task touches authentication, billing or a brittle subsystem, the router sends it to Astra or directly to a senior reviewer. The important asset is the routing evidence, not a blanket claim that one model is universally better.

Where GPT-6.1 Sol may fit

OpenAI's model-selection guidance places GPT-6.1 Sol between Luna and Astra: complex tasks where teams also need to manage time and cost. That makes it a sensible candidate for:

• coordinated coding work with automated tests and human merge review
• document and research workflows with source checks
• computer-use tasks in controlled environments with clear stop conditions
• professional deliverables that will be reviewed before external use

It is not automatically the right choice for every request. Luna may be more efficient for tightly scoped, frequent tasks. Astra may earn its premium for demanding work where measured quality, lower retry rates or reduced review effort matter more than token price.

What this launch does not prove

OpenAI's phrase "near-Astra performance" is provider positioning, not a universal result for your workload. Public benchmark summaries cannot tell you whether the model will handle your documents, codebase, tools, languages or failure modes.

The release also does not remove the need for access controls, safe test data, output validation, observability or human review. A lower-cost capable model can increase usage. That makes routing discipline more important, not less.

Implementation checklist

• Select one representative task lane.
• Remove secrets and prepare safe test inputs.
• Define required outputs and hard stop conditions.
• Create the acceptance rubric before running trials.
• Use matched permissions, tools and inputs.
• Record tokens, tool fees, retries, latency and reviewer time.
• Compare accepted results, not isolated outputs.
• Define when Sol is the default and when Astra is required.
• Keep humans responsible for high-impact actions.
• Re-test after material model, prompt or workflow changes.

Bottom line

GPT-6.1 Sol makes the middle of OpenAI's model lineup more interesting. Its listed standard token rates are substantially below Astra's, while OpenAI positions it for complex work. The credible response is a measured trial: test it on your real task, calculate complete-task cost and keep an evidence-based escalation path.

To define a repeatable task and review its output, use the 3-Step AI Workflow. For published claims, keep an evidence record with the AI claim verification workflow.

Sources

• OpenAI GPT-6.1 Sol model page
• OpenAI GPT-6 Astra model page
• OpenAI model-selection guidance
• OpenAI GPT-6 guide
• OpenAI API changelog
• Axios DevDay 2026 overview

Verified October 1, 2026.