GPT-6.1 Sol: API Cost, Reasoning and Coding Results

GPT-6.1 Terra is a lower-priced option for screen-based work, visual interpretation and routine writing. OpenAI continues to recommend Sol or Astra for the most complex coding tasks. Try Terra on tasks with a clear acceptance check, and compare repairs and elapsed time before changing a working Sol workflow.

At Standard rates below the long-input tier, Terra costs $1 input and $5 output per million tokens, half Sol’s $2 and $10. For the same assumed 50,000 fresh input tokens and 5,000 output tokens, the token bill is $0.075 versus $0.15. Count all turns, cache activity, tools and the execution environment when comparing accepted-task cost.

Start with Sol for recurring coding, research and computer-use work where you can check the result. Reserve Astra for the hardest reasoning tasks, especially when a failed attempt creates expensive rework. This starting strategy follows the roles in OpenAI’s 2026-10-02 model guide; the final choice depends on accepted results from your own workload.

Compare a model together with its reasoning effort and processing mode. Begin with Sol medium for planning and routine judgment, then try high for difficult debugging or careful review. OpenAI recommends testing xhigh or max when high falls short and keeping the increase only when the result repays the extra time and cost.

At standard short-context rates checked 2026-10-05, Sol costs $2 input, $0.10 cached input and $10 output per million tokens; Astra costs $10, $1 and $50 respectively. The uncached input and output gap is 5×; the cache-read gap is 10×. Repeated instructions and shared repository context benefit when they hit the cache. Include cache writes, misses, long-context tiers and tools in the full bill.

For an illustrative request with 50,000 uncached input tokens and 5,000 billed output tokens, Sol costs $0.15 and Astra $0.75. With all 50,000 input tokens served from an existing cache, those totals become $0.055 and $0.30. These examples exclude cache creation and tool charges. Including output charges, the fully cached Sol request costs about 18% of the Astra request.

Cost per successful task is total spend across all attempts divided by accepted results. For example, $20 spent across 100 attempts with 80 accepted results is $0.25 per success. Count failed attempts, repairs and escalation requests in total spend; track human review time separately.

Artificial Analysis’s comparison checked 2026-10-05 pairs Sol max with Astra xhigh. Both score 52 on its Intelligence Index; weighted cost per task is $0.72 versus $2.31, about a 3.2× gap. Sol produces 38k output tokens per task versus 17k, with task times around 694 versus 283 seconds. Output speed is much closer: 56 versus 60 tokens per second. These figures compare Sol max with Astra xhigh on the evaluator’s task set.

On 2026-09-29, Pawel Huryn reported a bug hunt across two repositories with 105 planted bugs, using max for both models. Astra fixed 45 for $33; Sol fixed 44 for $6.56. The author labels this single run n=1.

In another single-run comparison on 2026-09-29, J A Z I I used the same prompt at each model’s highest available reasoning. Sol took 10 minutes at a reported $1.50; Astra took 25 minutes at $11. The author preferred Sol’s visual output. Token counts and billing details were not supplied. Record both output speed and time to a usable artifact when comparing your own tasks.

A workflow to try is Sol medium first, Sol high when deeper reasoning could help, then Astra for an unresolved or especially valuable task. Pass the failed check, relevant evidence and attempted patch into the escalation so the next model can diagnose the remaining problem.

Set a repair budget and stop when it is exhausted. For example, allow one Sol repair before comparing an Astra attempt with the same acceptance test. Count both stages in the accepted-task cost. For a deadline-sensitive task, also count time spent waiting on the unsuccessful stage before deciding whether routing beats starting with Astra.

Use your usage logs to estimate cache-hit frequency and rerun representative tasks with the same tools and processing mode.

Select gpt-6.1-sol in the OpenAI API. Use the Responses API for tool calling; Chat Completions can use the model without tools. Keep your API key on the server. Start with one task and the default medium reasoning effort, then record usage and outcome before changing settings.

OpenAI lists low, medium, high, xhigh, and max for reasoning.effort. None and minimal are not supported. The model accepts image input but does not take audio or video input, and it returns text. The 1,050,000-token context is an upper limit; typical prompts can be much shorter.

One Codex user reported about an hour of Sol 6.1 Medium work on a Commodore 64 game: changes to the scrolling renderer, rebuilt PAL binaries, regression checks, and inspection in VICE. They said the tasks were handled without raising effort to high. Their observation about a slowly moving Work usage meter concerns a subscription allowance; it does not measure an API bill.

Speed is part of the split reaction. In a reply about Sol 6.1, one developer said an eight-finding PR review and repair produced a good result but took 1 hour 20 minutes, excluding E2E oversight. Others in the same thread were comfortable trading time for lower subscription usage. These are personal reports with different settings and tasks, so record wall-clock time beside accepted-task cost.

The visual-task reports are more divided. In a single HTML/SVG test, a creator asked Sol Max and two other GPT models to animate pelicans cycling, colliding, and displaying specific text; Sol took 23 minutes in that run. Another Codex user tried a jungle-safari game at medium effort and said the result lacked working gameplay even after a follow-up. Neither post is a controlled comparison with Sonnet or Opus, but both show what creators check beyond code that compiles: motion, labels, sound, and playability.

A browser-app developer reported that Sol Max made their app smoother by removing a frosted-glass effect they wanted to keep; they said Astra later restored the effect. This is one account, not a general failure rate. It suggests a concrete acceptance test for design-sensitive agent work: make the preserved visual properties explicit, capture before-and-after screenshots, and reject an optimization that changes the intended look.

Codex and Work subscription usage is governed by the account’s allowance and product settings. If an account shows a 500K context notice, read that as a condition for that subscription channel. A subscription usage meter and the direct API token bill have separate rules.

The GPT-6.1 Sol API has a 1,050,000-token context window. Its long-input price tier starts above 272,000 input tokens: input and cache rates double and output rises by 1.5× for the full request. For 300,000 uncached input tokens and 10,000 output tokens, Standard API cost is $1.20 + $0.15 = $1.35.

Check which credential the client uses before comparing spend. ChatGPT sign-in uses plan allowances or credits; an OpenAI API key uses API billing. Record complete API usage when budgeting a custom integration, and read the account’s usage page when choosing a subscription.

As checked 2026-10-13, standard pricing per 1M tokens is $2 input, $0.10 cached input, $2.50 cache writes, and $10 output for prompts with up to 272,000 input tokens. A request with more than 272,000 input tokens is charged 2× input and cache rates and 1.5× output for the full request. Fast mode is 2× Standard, while Batch and Flex are 50% lower; regional processing can add 10%.

A short-context run with 50,000 uncached input tokens and 5,000 output tokens costs $0.10 input plus $0.05 output, or $0.15 at standard rates. If the same input accompanies 20,000 output tokens, the example rises to $0.30. Changing effort can also change input turns, cache use and success.

The model has a 1,050,000-token window; its $2/$10 rate applies below the long-input threshold. Above the 272,000-input-token threshold, the higher rates apply to the full request. Estimate each request using its actual input length before treating a large repository dump as a cheap use of context.

Run the same task at low, medium, high, xhigh, and max only where the result can be judged. OpenAI describes lower effort as favoring speed and token economy and higher effort as allowing more reasoning. The model’s default is medium. Keep the starting context and success test fixed so the settings are the main difference.

Artificial Analysis reported that GPT-6.1 Sol reached near-Astra scores in its 2026-09-29 evaluation, while cost per task and output-token use changed across settings. Its Coding Agent Index even had xhigh outperform max. That is one evaluation setup, but it is a useful reason to measure the effort curve instead of assuming max always buys a better patch.

Record accepted results, output and reasoning token usage, tool calls, retries, and wall-clock time. Divide total API spend by successful runs at each effort level. A setting that adds cost but does not increase successful outcomes on your task set has not earned its place in that workflow.

Synthorai Engineering’s 2026-10-01 native-API tests used cache-avoiding prompts. At defaults, Sol medium cost $0.0020 per single-answer task, Sonnet high $0.0042 and Opus medium $0.0070; median times were 5.7, 3.9 and 5.5 seconds. Sol missed a knapsack answer in 7 of 18 calls; Sonnet answered all 234 calls correctly. The accuracy gap centered on one task.

On 2026-10-01, J A Z I I reported a same-prompt voxel-world build at the highest available reasoning: about three hours for each model, $30 for Sol and $100 for Sonnet. The author preferred Claude’s visual results and shared playable builds. The post omits token totals and cache usage, so its reported spend cannot be reconstructed as an API bill.

A first-person r/codex refactor test reported the same accepted result at medium effort on two $20 subscriptions, after both models needed one follow-up. Sol used 18% of its five-hour quota and Opus 7%. Those account meters measure subscription limits rather than dollars; they are useful when choosing a plan, alongside repeated task results.

For your own comparison, freeze the repository, instructions, tools and acceptance test. Record the model and effort, agent count, input/cache/output usage, wall time, tool calls, repair turns, total spend and accepted result. Keep subscription quota percentages separate from API-dollar estimates. A cheaper attempt that needs repair contributes both attempts to cost per accepted task.

Choose a realistic coding issue and run it three times at each effort setting worth considering. Freeze the repository revision, instructions, tools, and acceptance tests. For a visual project, include a reference screenshot, a list of design details to preserve, and a playable or rendered output check. A confident completion message without a working artifact is a failed attempt.

Keep spend and time for every attempt, including failed attempts and repair turns. Cost per accepted task is total spend divided by accepted results. Keep the API calculation separate from any Codex or ChatGPT subscription usage meter; the two do not price work the same way.