GPT-6.1 Terra vs Sol: How to Halve Your API Bill Without Paying It Back in Retries

Half the token price is not half the bill

If you run GPT-6.1 Sol in production, the launch-day pitch is hard to ignore: change one model ID and your OpenAI bill drops by half. Sometimes that is exactly what happens. Sometimes the cheaper model fails more often, you retry, a human fixes the rest, and next month's bill is higher than before. Both outcomes start with the same one-line change.

OpenAI released GPT-6.1 Terra on October 26, 2026, with the API model ID gpt-6.1-terra. Its model page lists every Standard rate at half of GPT-6.1 Sol's, and the launch post says it finishes tasks more than three times faster. This post gives you the one number that decides which outcome you get, shows the setting that quietly eats the discount, and walks you through checking your own workload before you move any traffic.

Every row has the same ratio. That makes this comparison unusually clean: for any mix of input, cached, and output tokens, a Terra request costs exactly half of the same request on Sol. Both models also have the same 1,050,000-token context window and 128,000-token output limit, so context size is not a reason to pick one over the other.

The best case: $7,200 a year back on one workload

The examples below use one workload: 3,000 input tokens and 600 output tokens per request, 100,000 requests a month, Standard pricing, no caching unless a section says so. Cost per request is (3,000 × input price + 600 × output price) ÷ 1,000,000.

If Terra did your work exactly as well as Sol, the switch would save $600 a month, or $7,200 a year, on this workload. Prompt caching does not change the ratio. With 2,500 of the 3,000 input tokens served from cache, a request costs $0.003625 on Terra and $0.00725 on Sol: still half. Notice where the money goes in that cached case: output is $0.003 of Terra's $0.003625, about 83% of the request. Output length will move your bill more than input does.

The catch is the phrase "exactly as well." Nobody switches models for the token price alone. You switch for the cost of getting work done, and that depends on how often the answer is usable.

The 45% rule: the one number to check before you switch

Say a task is done when its answer passes your check: valid JSON, a passing test, a ticket a reviewer accepts. If you retry failed tasks until one passes, the expected cost per completed task is the cost per request divided by the success rate. Terra is cheaper when:

Terra cost per request ÷ Terra success rate  <  Sol cost per request ÷ Sol success rate

Terra break-even success rate = Sol success rate × (Terra cost ÷ Sol cost)
                              = Sol success rate × 0.5

Sol at 90%  →  Terra must beat 45%

Here is that rule in numbers. The success rates are assumptions chosen to show the formula, not test results for either model.

In this example Terra costs half as much per call and still loses: at 40% it needs 2.5 calls per completed task, while Sol needs 1.11. Move Terra's rate and the picture changes fast.

The gap between 45% and 90% is wide. That is good news for Terra on simple, well-specified tasks such as extraction, classification, or rewriting, where a smaller model can stay close to the larger one. It is a much tighter bet on long, multi-step work, which is where the next section matters.

Don't max out Terra: how reasoning effort eats the discount

The 45% rule assumes both models use the same tokens per task. The easiest way to break that assumption is to compensate for a smaller model by turning its reasoning effort all the way up. The per-token price does not change, but higher effort usually means more reasoning tokens, and reasoning tokens bill as output, the expensive side of the rate card. Agent loops do the same thing from another direction: a model that needs more steps re-sends a growing context on each one, and every step is billed.

So the fair comparison is not Terra at max against Sol at max. It is Terra at the effort it needs against Sol at the effort it needs. Benchmark trackers such as Artificial Analysis publish scores and cost per task by effort level; their numbers move as benchmarks are revised, so treat them as a reason to test, not as your answer.

If Terra spends r times Sol's billed tokens per task, its cost per task is 0.5 × r of Sol's, and the break-even rate scales with it:

Terra break-even success rate = Sol success rate × 0.5 × r

r = token ratio (Terra billed tokens per task ÷ Sol billed tokens per task)

At twice the tokens, Terra has to match Sol's success rate just to break even. Past that, no success rate makes it cheaper. So when you test Terra, try it at more than one effort setting, and try Sol one step lower than you run it today. Record the billed tokens from each response's usage field, not just whether the task passed. For agents, sum the usage across every step of the task.

Still on GPT-5.6 Terra? That switch is the easy one

Not everyone reading this runs Sol. If your traffic still sits on GPT-5.6 Terra, the math is much friendlier. GPT-5.6 Terra lists $2.00 input, $0.20 cached input, and $12.00 output per million tokens. GPT-6.1 Terra costs less on every line, and output, usually the biggest share of the bill, drops from $12.00 to $5.00.

OpenAI's launch post also reports GPT-6.1 Terra ahead of GPT-5.6 Terra on its own coding, computer-use, and factual-accuracy evaluations. Those are vendor numbers, so still run your test set, but here the price and the claimed quality point the same way. Test this move before you think about Sol.

Get both: Terra first, Sol only when it fails

You don't have to pick one model. If your code can tell when an answer fails, you can send every request to Terra and only pass the failures to Sol. The failed Terra call is still billed, so the route costs:

cost per request = Terra cost + (Terra failure rate × Sol cost)
                 = $0.006 + (failure rate × $0.012)

equals Sol alone ($0.012) when Terra passes 50% of the time

This route only works when the check is cheap and automatic, such as schema validation, a unit test, or a rule-based filter. Every fallback also waits for two model calls, which hurts p95 latency. For the general version of this rule with other model pairs, see when a fallback model should become the primary. The LLM Retry & Fallback Cost Calculator prices this route with your own rates.

When to keep Sol and when to test Terra

• Test Terra first for single-call work with a clear pass/fail check: extraction, classification, short rewrites, image-to-catalog matching. The 2x price headroom is large, and failures are easy to count.
• Test Terra with token tracking for agents and multi-step tasks. The success rate alone is not enough; a Terra run that takes twice as many steps costs as much as Sol.
• Keep Sol where a failed answer is expensive to catch: work that a person has to review, or where a wrong answer reaches a customer before your check does. Halving the API line does not help if review time goes up.
• Keep Sol for your hardest coding work. OpenAI's own launch post says GPT-6.1 Sol and GPT-6 Astra remain the better choice for the most complex coding tasks.
• Consider the Terra-first route when you already validate outputs. Above a 50% pass rate it saves money without giving up Sol's answers on the hard cases.

Run the comparison on your own workload

The numbers above use round assumptions. Here is the order that gets you to a decision with your own data.

• Step 1. Pick 200 to 500 real tasks with a written definition of success. Run each one on both models with the same prompt and settings.
• Step 2. Record, per model, the share of tasks that passed and the average billed input and output tokens per task from the usage field.
• Step 3. Open the Model Switch Cost Calculator. Set Current model to GPT-6.1 Sol and Target model to GPT-6.1 Terra. Enter your input tokens, output tokens, and requests per month.
• Step 4. Open Compare cost per successful task. Enter Sol's rate as Current success rate and Terra's as Alternative success rate, and set Success rate source to Measured if they came from your test set. The panel shows cost per completed task on each model and the Break-even alternative success rate.
• Step 5. The calculator prices both models on the same token counts. If your test showed Terra using more tokens, multiply the break-even rate by your token ratio before you compare it with Terra's measured rate.

For the full explanation of why the cheapest token rate can lose, read the cheapest LLM can cost more per successful task. Every price here comes from the AICostBudget dataset, which links each row to OpenAI's own pricing page; the model price monitor logs any change with its date and source. Recheck before you commit, and treat your OpenAI invoice as the final word on what you paid.

FAQ