What GPT-6.1 Sol Really Costs: Beyond the $2 / $10 Price Tag

GPT-6.1 Sol has the same list price as GPT-6 Sol: $2 per million input tokens and $10 per million output tokens. Your actual bill depends on three other things: how often you hit the cache, whether you cross 272K input tokens, and how many reasoning tokens the model burns. This post goes through each one.

The full price list

Standard rates (per 1M tokens)

These are the rates listed on AIHubMix. Each model costs the same on its OpenAI and Azure routes, and GPT-6.1 Sol's rates match the official ones on OpenAI's GPT-6.1 Sol model page.

Long context and web search

Once input passes 272K tokens, the whole request moves to the higher column. Web search costs $0.01 per request on both tiers.

The real change: cache reads at 5% of input

The list price didn't move. Cache reads did, from 10% of the input rate ($0.20) down to 5% ($0.10). OpenAI's prompt caching guide puts it plainly: cache reads cost 0.1× input on most models and "0.05× on GPT-6.1 Sol."

This matters because agents resend the same material on every step: system prompt, tool definitions, repo context, and conversation history. Most of their input is repeated content. For these workloads, the cached rate is effectively your real input price.

Worked example: one coding-agent task

Assumptions:

• A 200K-token fixed prefix (system prompt, tools, repo context)
• 50 steps, each adding 2K new input tokens and producing 3K output tokens (including reasoning)
• To keep it simple, the prefix stays the same size, is written to cache on step 1, and hits on all 49 remaining steps

In a real run the history grows with every step. Even counting only the 2K of new input per step, the request would pass 272K around step 37 (see the 272K cliff below). The figures below are estimates from list prices under these assumptions.

Three takeaways:

1. Caching is the biggest lever. Same model, same work, and the uncached run costs nearly seven times as much ($21.70 against $3.23).
2. 6.1 Sol is about 23% cheaper than 6 Sol here ($3.23 against $4.21), while also scoring higher.
3. For cache-heavy work, Astra costs more than the 5× list-price gap suggests. In this example it costs 6.5 times as much as 6.1 Sol ($21.05 against $3.23), because Astra discounts cached input by 90% and 6.1 Sol discounts it by 95%.

That lines up with OpenAI's own per-task cost figures, as compiled by Vellum and The Next Web: about $1.50 for 6.1 Sol against $7.70 for Astra on DeepSWE, $1.30 against $9.30 on OSWorld, and $5.47 against $23.80 on Terminal-Bench Science.

One caveat: OpenAI says Astra usually needs fewer output tokens to finish the same task. Compare models on cost per task, not cost per token.

Cache writes aren't free

Cache writes on 6.1 Sol cost 1.25× the input rate for the default 30-minute cache lifetime. If a prefix is only used once, caching makes it 25% more expensive. Using the formula from OpenAI's guide:

• One write plus one read: 1.35× regular input cost (1.3× on 6.1 Sol), against 2× without caching
• One write plus nine reads: about 2.15× (about 1.7× on 6.1 Sol), against 10×

The minimum cacheable prompt is 1,024 tokens. Run OpenAI's break-even formula at 6.1 Sol's 0.05× read rate, and a prefix of 51 tokens or fewer never pays off. Across 10 or more requests, expanding anything over 174 tokens to 1,024 with useful, stable content comes out cheaper. (OpenAI's guide gives 102 and 221 tokens, which assume the 0.1× read rate most other models use.)

For calls where nothing in the prompt repeats, such as one-off questions about documents you send only once, use explicit mode (prompt_cache_options.mode: "explicit") with no breakpoints. The request then creates no cache writes, so you aren't charged for any.

The 272K cliff

6.1 Sol accepts 1.05M tokens of context, but once input goes past 272K, the entire request moves to the higher rate, not just the tokens over the line.

Ten thousand more input tokens nearly doubles the bill.

How to stay under it:

• Count tokens client-side and compact or trim before you reach 272K
• Retrieve the relevant parts of long documents instead of sending the whole thing
• When you genuinely need long context, put the fixed part in a cached prefix

Compacting restarts the cache, so it costs one full cache write. Crossing 272K bills every request after it at 1.5 to 2 times the rate. The more steps a run has left, the more compacting pays.

How reasoning effort shows up on the bill

Reasoning tokens bill at the output rate, $10 per million. The same task can use far more reasoning tokens at max than at low.

OpenAI's reported per-task costs give a sense of scale (these are different benchmarks, so only compare the magnitudes):

• AutomationBench (medium): ~$0.30
• GDP.pdf: ~$0.38
• DeepSWE (high): ~$1.50
• Terminal-Bench Science (max): ~$5.47

The reasoning-effort post in this series covers how to pick a level. One reminder here: changing the reasoning effort mid-conversation invalidates the cache. OpenAI's guide explains that the setting can rewrite the hidden system instructions at the start of the prompt, so nothing after them matches. Pick a level when a conversation starts and keep it.

How it compares at this price point

6.1 Sol and Claude Sonnet 5.5 have the same list price and, per Anthropic's pricing page, the same $0.10 cached rate. The difference is long context: Sonnet 5.5 bills its full 1M window at the standard rate, so past 272K it's the cheaper of the two per token. They're also strong at different things. On AutomationBench, for example, Sonnet 5.5 scores well ahead. When two models cost the same per token, the one with the lower cost per task on your workload is the cheaper one.

The AIHubMix compare page shows both models' specs and prices side by side, and one API key works for both, so you can run the same tasks through each.

Prices are as listed on AIHubMix and on OpenAI's and Anthropic's pricing pages on October 22, 2026, and may change.

Cost checklist

1. Put stable content first. System prompt, tool definitions, and reference material go at the top. Timestamps and per-user data go at the end.
2. Append, don't rewrite. Summarizing, truncating, and compacting all restart the cache.
3. Keep the tool list stable. Don't add or remove tools per request. Use tool_choice or allowed_tools instead.
4. Pick one reasoning effort per conversation. Changing it mid-conversation restarts the cache.
5. Stay under 272K input.
6. Route by task. Luna for simple high-volume work, 6.1 Sol for most things, Astra for the hardest problems.
7. Watch three numbers: cached_tokens, cache_write_tokens, and reasoning_tokens.

The bottom line: the list price didn't change, but cache reads got 50% cheaper. For agent workloads, that makes 6.1 Sol the best-value model in the GPT-6 family, as long as you use caching well and stay under 272K.

FAQ

How much does GPT-6.1 Sol cost?
$2 per million input tokens, $10 per million output tokens, $0.10 for cached input, and $2.50 for cache writes. Requests over 272K input tokens bill at $4 input and $15 output for the whole request.

Is it cheaper through AIHubMix or OpenAI directly?
The standard rates are the same. AIHubMix's OpenAI and Azure routes both match OpenAI's official pricing, including the over-272K tier.

Why is my bill higher than I estimated?
Three common reasons: reasoning tokens bill at the output rate; a request crossed 272K input and moved entirely to the higher rate; or you missed the cache or paid write charges on prefixes used only once.

Do cache writes cost extra?
Written tokens bill at 1.25× the input rate. That replaces the normal input charge rather than adding to it. A prefix pays for itself from its second use. For prefixes used only once, explicit mode with no breakpoints creates no writes.

How does 6.1 Sol's cost compare with Astra's?
Astra's list price is five times 6.1 Sol's. In the cache-heavy agent example above, Astra costs $21.05 against 6.1 Sol's $3.23, about 6.5 times as much, because 6.1 Sol discounts cached input more steeply. Astra often uses fewer output tokens per task, so compare cost per task on your own workload.

Is Claude Sonnet 5.5 cheaper than GPT-6.1 Sol?
Up to 272K input, they cost the same: $2 input, $10 output, and $0.10 for cached input. Above 272K, Sonnet 5.5 is cheaper per token because it has no long-context surcharge. Which one is cheaper per task depends on how many tokens each needs for your work.

Does changing the reasoning effort mid-conversation cost more?
Yes. The setting can change the hidden instructions at the start of the prompt, so the cached prefix stops matching and the next request writes the cache again. Choose a level at the start of a conversation and keep it.

Keep reading: the GPT-6.1 Sol series

• Reasoning tokens are the easiest cost to lose track of. Which tasks are fine at low, and when max pays off: Choosing a Reasoning Effort for GPT-6.1 Sol: low to max
• New caching rules can raise your bill after you migrate. Breakpoints, write billing, TTL, and eight other pitfalls: Migrating to GPT-6.1 Sol: 9 Things That Can Go Wrong
• Cheaper, but is it good enough? How close 6.1 Sol gets to Astra on coding and computer use: GPT-6.1 Sol vs GPT-6 Sol: A One-Week Upgrade That Nearly Catches Astra

Sources

• GPT-6.1 Sol (OpenAI)
• Prompt caching (OpenAI)
• Pricing (Anthropic)
• GPT-6.1 Sol (AIHubMix)
• GPT-6.1 Sol benchmarks explained (Vellum)