What GPT-6.1 Terra Really Costs: Effort Levels, the 272K Line, and Caching

GPT-6.1 Terra launched on 26 October 2026 at $1 per million input tokens and $5 per million output tokens, half of GPT-5.6 Terra's input price and well under half of its $12 output price. The list price is only the starting point. Three things decide what a Terra workload actually bills:

• Reasoning effort. Reasoning tokens bill as output, and the gap between effort levels is several-fold.
• The 272K line. Once a request's input crosses 272,000 tokens, the whole request moves to a higher rate.
• Caching. A cached prefix costs 5% of normal input; a prefix that misses or gets rewritten costs full price or more.

Below: one workload priced with every assumption stated, the billing rules that are easy to miss, cost per task against GPT-6.1 Sol, Claude Sonnet 5.5 and GPT-5.6 Terra, and a Python sample that logs the usage fields behind your bill. AIHubMix serves Terra as gpt-6.1-terra at the same prices as OpenAI.

The price card

All prices are USD per million tokens, from the OpenAI model page. AIHubMix's model page lists the same standard input, cache-read and output prices, but no cache-write or long-context line; its caching doc gives a single 1.25x write rate, so a 12-hour premium isn't published there.

OpenAI prints one set of rates and states the rest as a rule: past 272K input tokens, input and cache rates double and output rises 1.5x for the whole request, which puts a 12-hour write at $5.00. AIHubMix publishes no long-context line for Terra, so what the gateway bills past 272K is unconfirmed.

OpenAI also sells Batch and Flex processing at 50% off, Fast mode at 2x, and regional processing at +10%. Those are OpenAI's terms. AIHubMix doesn't serve OpenAI's Batch API (GET /v1/batches returned 404 in AIHubMix's checks on 27 October). The same checks found service_tier "flex" accepted and echoed as "flex", and "priority" accepted and echoed as "fast", which on OpenAI's terms is the 2x Fast mode. AIHubMix's price list for Terra shows only standard lines, so neither billed rate is confirmed. Check your usage log rather than assuming a discount.

The models compared later, at official prices (the same on AIHubMix):

Billing rules that are easy to miss

Reasoning tokens are output tokens. A request that returns 2,000 visible tokens after 8,000 reasoning tokens bills 10,000 output tokens. Read cost from the usage object, not from the answer's length.

The 272K line reprices the whole request. It isn't a marginal rate on the tokens above 272,000. Every input token in the request doubles and every output token rises 50%. The arithmetic at the boundary, with no caching and 20,000 output tokens in both cases:

Eleven percent more input roughly doubles the bill. Terra accepts up to 922,000 input tokens (1,050,000 context); it just charges more past 272K.

Cache writes aren't free. On GPT-5.6 and later, writing a prefix to the cache bills at 1.25x the input rate for the default 30-minute lifetime and 2.5x for a 12-hour lifetime, which is only available on the Responses API. Reads cost 0.05x on Terra, whichever lifetime you chose. Per OpenAI's prompt caching guide, these are total rates, not surcharges: each input token bills once, as ordinary input, a read, or a write. The minimum cacheable prefix is 1,024 tokens.

Chat Completions and Responses don't share a cache on AIHubMix. In AIHubMix's checks, a 9,623-token developer prefix was written on the first Responses call and read on calls two and three. The same prefix sent to Chat Completions right afterwards was written again, with no hit. Mixed traffic pays for two sets of writes.

Effort only takes effect on Responses through AIHubMix. On the Responses API, a prime-sum prompt produced 72 output tokens at effort none and 1,153 at max (1,078 of them reasoning). On Chat Completions, setting reasoning_effort made no consistent difference across the same tests (none and max both landed around 200-300 reasoning tokens from run to run), which suggests that route runs at a fixed effort. If you plan to save money with a lower effort, send those requests to Responses.

Built-in web search bills per call. AIHubMix lists web_search_requests at $0.01 per call, on top of tokens.

A realistic month, priced line by line

Take a support or document-processing workload that sends 10,000 requests a month through the Responses API. The assumptions:

• each request carries a 2,500-token stable prefix (system prompt, tool definitions, reference rules) that hits the cache;
• each request adds 1,500 fresh input tokens (the user's message or document);
• each request returns 1,500 output tokens, reasoning included, at medium effort (Terra's default);
• every request stays under 272K input, so standard rates apply;
• cache writes are left out of the totals (see the note under the table).

Over the month that is 25M cached tokens, 15M fresh input tokens and 15M output tokens.

Cache writes add little here. Each time the 2,500-token prefix is written, those tokens bill at $1.25 per million instead of $0.05, about $0.003 extra per write.

Two variations show where the money goes.

Without caching. If the prefix never hits (it changes per request, or traffic is spread across routes), all 40M input tokens bill at $1: $40 for input plus $75 for output, $115 in total. Caching saves $23.75 a month, about a fifth of the bill.

At max effort. Artificial Analysis measured about 6,000 output tokens per task at medium and 35,000 at max on its Intelligence Index, a ratio of roughly 5.8x. Scaling the 1,500 output tokens by 35/6 gives 8,750 per request, or 87.5M a month. Output then costs 87.5M x $5 = $437.50, and the month totals $1.25 + $15.00 + $437.50 = $453.75, about five times the medium bill. Max effort costs far more than losing the cache.

The output line dominates in every case. At medium it is $75 of $91.25, 82% of the bill. That is why effort, not input pricing, is the first setting to look at.

Cost per task against Sol, Sonnet 5.5 and GPT-5.6 Terra

Same workload, same token counts (25M cached, 15M fresh input, 15M output), each model at its own official prices:

At equal token counts Terra costs half of Sol and Sonnet 5.5 and about 42% of GPT-5.6 Terra. Equal token counts is the catch: models spend different amounts of reasoning on the same task, and Terra at a higher effort can spend more tokens than Sol at a lower one.

Measured cost per task shows that. The figures below come from Artificial Analysis, an independent benchmark that ran each model through its Intelligence Index at the effort shown.

Sonnet 5.5's row is Artificial Analysis's default max-effort setup.

Three readings follow. Terra at medium is the cheapest row in the table, and Artificial Analysis calls low and medium effort Pareto-optimal for Terra. Turning reasoning off didn't save money in this run: no reasoning cost $0.11 per task and scored 33. At the other end, Terra at max ($0.40) costs about the same as Sol at xhigh ($0.39), which scores higher, and only matches Sol at medium for nearly twice the price. Sonnet 5.5 scores highest, but at max effort it spent about 197,000 output tokens per task.

Other published tests point the same way. In Plotly's data-analysis benchmark, run at default effort through OpenRouter, Terra scored 40 of 43 for $1.31 per full run against Sol's 43 of 43 for $2.61, at about 1,460 output tokens per question. OpenAI's own launch charts, which are self-reported and here as transcribed by Kingy AI, put Terra's max-effort task cost on the OSWorld 2.1 offline set at $1.19 against Sol's $1.15. At max effort on agent work, Terra's per-token discount can disappear.

Who pays more than expected

• Teams running max effort by default. The bill can be five times the medium bill on the same traffic. Codex users on Reddit report Terra at high effort using up plan limits quickly; one said 40% of a five-hour limit went in 20 minutes. Those are anecdotes, but consistent with the token counts above.
• Long-context RAG close to 272K. A retrieval step that sometimes adds a few more chunks will push some requests over the line, and those requests cost roughly double.
• Mixed Chat Completions and Responses traffic. The two routes keep separate caches on AIHubMix, so the same prefix is written twice, and effort settings on the Chat route have no visible effect.

Steps that lower the bill

1. Set effort per workload, not per account. Start at medium, Terra's default, and test low or none on simple jobs such as extraction, classification and formatting. Measure both quality and cost on your own prompts, since none wasn't cheaper than medium in Artificial Analysis's run. Keep high and max for requests that fail at medium.

2. Keep the stable prefix first and the route fixed. Put the system prompt, tool definitions and reference material at the start of every request, in the same order, and everything that varies (user input, timestamps, retrieved chunks) after it. A prefix needs at least 1,024 tokens to be cached. Send the workload to one route; on AIHubMix, use Responses, where effort takes effect.

3. Use explicit mode to stop paying for writes you won't reuse. With prompt_cache_options.mode set to "explicit", only the breakpoints you mark get written. Content after the last breakpoint bills at the ordinary input rate with no write charge, which suits per-request material such as the user's question. Explicit mode with no breakpoint means no caching at all, and AIHubMix's checks confirmed such a request wrote nothing.

4. Choose the cache lifetime with arithmetic. Per million prefix tokens, a 30-minute write costs $1.25 and a 12-hour write $2.50; reads cost $0.05 either way. If gaps in traffic mean the prefix would be written three or more times in 12 hours under 30-minute caching ($3.75 or more), one 12-hour write is cheaper. At two writes ($2.50) they break even. With steady traffic that keeps the 30-minute entry alive, stay on 30 minutes. AIHubMix's checks confirmed the 12-hour setting works on Terra: a 9,020-token prefix was written as ttl_12h_tokens on the first call, and the second call read 9,007 of those tokens.

5. Stay under 272K input. Cap retrieval at a token budget rather than a chunk count, drop stale turns, and summarize long histories before they cross the line. OpenAI also documents a compaction feature for long contexts, which AIHubMix hasn't checked on Terra.

6. Change effort with configuration_update, not the request field. OpenAI's GPT-6 model guide recommends keeping request-level effort fixed and adding a configuration_update input item to raise or lower effort mid-conversation. AIHubMix accepted a configuration_update item on Terra (200) in its 27 October checks.

7. Log the usage fields on every response. The fields that explain a Terra bill are input_tokens_details.cached_tokens (billed reads), cache_write_tokens and its ttl_30m_tokens and ttl_12h_tokens split, and output_tokens_details.reasoning_tokens. Divide total cached tokens by total input tokens to get the cache hit rate, grouped by day or by feature.

Logging cost per request in Python

The sample uses the OpenAI SDK against AIHubMix's Responses endpoint. It sets reasoning effort, passes prompt_cache_options through extra_body, and prints the usage fields with an estimated cost at standard rates. Setup steps are in AIHubMix's Responses API docs, and caching behaviour on the gateway is covered in the AIHubMix caching docs.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://aihubmix.com/v1",
    api_key=os.environ["AIHUBMIX_API_KEY"],
)

# Keep this identical across requests so it can be cached (1,024+ tokens).
STABLE_PREFIX = open("support_rules.txt").read()

# Terra standard rates, USD per 1M tokens, input up to 272K.
PRICE = {"input": 1.00, "cached": 0.05, "write_30m": 1.25,
         "write_12h": 2.50, "output": 5.00}

resp = client.responses.create(
    model="gpt-6.1-terra",
    reasoning={"effort": "low"},  # none, low, medium, high, xhigh, max
    input=[
        {"role": "developer", "content": STABLE_PREFIX},
        {"role": "user", "content": "Classify this ticket: refund not received."},
    ],
    extra_body={"prompt_cache_options": {"ttl": "30m"}},  # or "12h"
)

u = resp.usage.model_dump()
inp = u["input_tokens_details"]
cached = inp.get("cached_tokens", 0)
writes = inp.get("cache_write_tokens", 0)
by_ttl = inp.get("cache_write_tokens_details") or {}
w12 = by_ttl.get("ttl_12h_tokens", 0)
w30 = writes - w12
ordinary = u["input_tokens"] - cached - writes
reasoning = u["output_tokens_details"].get("reasoning_tokens", 0)

cost = (ordinary * PRICE["input"] + cached * PRICE["cached"]
        + w30 * PRICE["write_30m"] + w12 * PRICE["write_12h"]
        + u["output_tokens"] * PRICE["output"]) / 1_000_000

print(f"input={u['input_tokens']} cached={cached} writes={writes} (12h={w12})")
print(f"output={u['output_tokens']} reasoning={reasoning}")
print(f"estimated cost=${cost:.6f}")

The formula follows OpenAI's caching guide: ordinary input is input_tokens minus cached_tokens minus cache_write_tokens, and the write total isn't added again on top of its parts. Above 272,000 input tokens, swap in the long-context rates ($2, $0.10, $2.50 for 30-minute writes, $5 for 12-hour writes, $7.50 output). Send the same prefix twice within 30 minutes and the second response should show it under cached_tokens; if not, something in the prefix changed.

FAQ

Is GPT-6.1 Terra cheaper on AIHubMix than at OpenAI?
No. AIHubMix lists the same standard rates: $1 input, $0.05 cache read and $5 output per million tokens. It publishes no cache-write or long-context line for Terra, so the $1.25 and $2.50 write rates and the 2x rates past 272K are OpenAI's terms until your usage log confirms what the gateway bills.

Is the Batch or Flex discount available through AIHubMix?
Not as a confirmed option. The 50% Batch and Flex discount is OpenAI's, and AIHubMix doesn't serve OpenAI's Batch API. Flex requests were accepted in AIHubMix's checks, but AIHubMix's price list shows only standard rates for Terra, so check your usage log before counting on a lower price.

Do reasoning tokens cost extra?
They bill at the output rate, $5 per million, as part of output_tokens. The usage object reports them separately as reasoning_tokens so you can see how much of the output was thinking.

What happens to a request at 280,000 input tokens?
The whole request bills at long-context rates: $2 per million input, $0.10 cached, $7.50 output. Not just the 8,000 tokens over the line.

Is the 12-hour cache worth it?
Only when a 30-minute entry would otherwise be written three or more times in 12 hours. A 12-hour write costs $2.50 per million tokens against $1.25 for 30 minutes, and reads cost $0.05 either way.

Why does max effort cost so much more?
Artificial Analysis measured about 35,000 output tokens per task at max against 6,000 at medium, and cost per task rose from $0.10 to $0.40. In the worked example above, moving from medium to max takes the month from $91.25 to $453.75.

Is Terra always half the price of Sol?
Per token, yes. Per task, not always: Terra at max costs about as much per task as Sol at xhigh in Artificial Analysis's run, and Sol scored higher there.

Keep reading: the GPT-6.1 Terra series

• To see what the halved price buys compared with the model it replaces: GPT-6.1 Terra vs GPT-5.6 Terra: Half the Price, What Changed, and Who Should Switch
• Before moving traffic to Responses so effort settings and caching work: Migrating to GPT-6.1 Terra: Fix the temperature 400s, Move Tools to Responses, and Set Up Codex
• If you are weighing Terra against a rival at twice the token price: GPT-6.1 Terra vs Claude Sonnet 5.5: Which Mid-Tier Model for Screen and Document Agents?
• When max-effort Terra costs as much as Sol per task: GPT-6.1 Terra vs GPT-6.1 Sol: Which Tasks Still Need Sol?

Sources

• OpenAI, GPT-6.1 Terra model page: prices, long-context rule, context limits, effort levels.
• OpenAI, Prompt caching guide: write and read rates, cache lifetimes, explicit mode, usage fields.
• AIHubMix, GPT-6.1 Terra model page: AIHubMix pricing and access.
• Artificial Analysis, GPT-6.1 Terra pushes the cost-efficiency frontier: cost and output tokens per task by effort level.
• Kingy AI, GPT-6.1 Terra: Benchmarks, Pricing, Specs, and How It Compares: pricing tiers, the 272K boundary example, and transcribed OpenAI chart values.