GPT-6.1 Terra Pricing: What $1 and $5 Actually Buy You

The rate card for GPT-6.1 Terra is four numbers long, and three of them are the ones people quote: one dollar per million input tokens, five dollars per million output, five cents per million cached input. The fourth — $1.25 per million cache-write tokens — is the one that decides whether your bill halves or merely dips. This is a pricing page, not a launch story: it takes the full card apart line by line, prices three real workloads across GPT-6.1 Terra, GPT-6.1 Sol, GPT-5.6 Terra, GPT-6 Astra and GPT-6 Luna, and shows where the half-price claim survives contact with a production invoice and where it quietly stops being true.

Every figure below comes from OpenAI's model documentation for GPT-6.1 Terra, read on October 27, 2026, and from the live listings on Artificial Analysis for the independent cost-per-task numbers. Where a number is vendor-reported, it says so. Nothing here is a forecast dressed as a measurement.

The card, line by line

Standard rates on GPT-6.1 Terra are $1.00 per million input tokens and $5.00 per million output tokens. Cached input is $0.05 per million. Those are the numbers in every headline, and they are correct as far as they go.

What the headlines leave out is that a cache is not free to fill. Writing to the cache costs $1.25 per million tokens with 30-minute retention, or $2.50 per million with 12-hour retention. If your workload is one long system prompt reused across thousands of short requests, the cache pays for itself within a handful of calls. If your workload is a different 40,000-token document every time, you are paying $1.25 on top of the $1.00 input rate for the privilege of storing something you will never read again — and cached input at five cents never enters the picture.

The other modifiers stack in ways that are easy to miss:

• Long context — any request above 272,000 input tokens bills at $2.00 input and $7.50 output for the entire request, not just the excess. Cached input doubles to $0.10 and cache writes to $2.50 at that tier.

• Batch and Flex — 50% below standard, so $0.50 input and $2.50 output. This is the cheapest competent general-purpose rate on OpenAI's card.

• Fast mode — 2× standard, or $2.00 input and $10.00 output.

• Regional processing — a 10% premium where a region is offered. Terra does not support UAE inference residency, so that premium is not available to every buyer who wants it.

• Reasoning effort — none, low, medium, high, xhigh and max. The default is medium. Effort does not change the per-token price; it changes how many tokens the model spends thinking, which is why the same prompt can cost three times more at max than at low.

The per-token card, in other words, is a menu with six dials and two cliffs. The cliffs are the 272K threshold and the cache-write fee. The dials are effort, batch, fast, regional, and cached versus uncached input.

Three workloads, three bills

Take a support-triage pipeline: a 2,000-token system prompt, a 1,500-token ticket, and a 400-token answer. Uncached, that is 3,500 input tokens at $1.00 per million and 400 output tokens at $5.00 per million — $0.0035 plus $0.0020, or $0.0055 per ticket. Ten thousand tickets a day costs $55. With the system prompt cached and the cache staying warm, input drops to roughly 1,500 uncached tokens plus 2,000 cached at $0.05, and the same ticket costs about $0.0037. The saving is 33%, not 50%, because output was always the more expensive half.

Now a document pipeline: 80,000 input tokens of contract text and 2,000 output tokens of summary. That is $0.08 in, $0.01 out — nine cents a document. On GPT-5.6 Terra at $2.00 and $12.00 the same job is $0.16 in and $0.024 out, or 18.4 cents. The bill halves, and output is where the bigger proportional cut lives: 58% off, not 50%.

Then the browser agent, which is the workload Terra was actually sold for. Each step sends a screenshot plus the task state and asks for one action. Assume 3,000 input tokens and 150 output tokens per step, and twenty steps per task. That is 60,000 input and 3,000 output tokens per task — $0.06 in, $0.015 out, 7.5 cents per completed task before retries. Add a 30% retry rate and you are at about 9.8 cents. This is where cost per task, not cost per token, becomes the only number that matters.

The 272K cliff, worked through

Because the long-context multiplier applies to the whole request, crossing 272,000 input tokens is not a marginal cost. A 300,000-input, 3,000-output request bills at $2.00 and $7.50 per million: $0.60 in, $0.0225 out, $0.6225 total. The same request at 270,000 input tokens bills at $0.27 in and $0.015 out, $0.285 total. You added 30,000 tokens and paid 118% more.

That matters because GPT-6.1 Terra's context window is 1,050,000 tokens with a 922,000-token maximum input. The window invites workloads that the price card punishes. If your pipeline routinely sends 300K to 500K tokens, the honest comparison is not Terra at $1 against Sol at $2 — it is Terra at $2 against Sol at $4, and Terra at $7.50 output against Sol at $15. The 50% gap survives, but the absolute numbers are twice what the headline suggests: a 400,000-input, 4,000-output request is $0.83 on Terra and $1.66 on Sol.

Where the half-price claim stops

Fast mode is the clean example. GPT-6.1 Terra at 2× is $2.00 input and $10.00 output — exactly GPT-6.1 Sol's standard list price, for a model that Artificial Analysis scores four index points lower. If your workload needs Terra's speed badly enough that you pay the fast multiplier, the price argument for Terra over Sol disappears entirely. What remains is a latency argument, and it is only an argument if the measured speed gap is real.

The second place it stops is effort. At xhigh or max, Terra can spend more tokens than Sol at low or medium to reach a similar answer. Hacker News commenters made this point within hours of launch: "Terra at xhigh costs more than Sol at low and scores worse" was the recurring version. The price card cannot answer that, because the card prices tokens and the workload decides how many.

The third place is cache-write-heavy traffic. At $1.25 per million written, a pipeline that rebuilds a 50,000-token context on every request pays $0.0625 per request before it reads a single token. On GPT-5.6 Terra the same write cost $2.50 — so the new model is still cheaper — but the cache line is now 55% of the input bill, not 20%.

Cost per finished task is the number to budget against

Artificial Analysis publishes both an Intelligence Index and a cost per index task. On its live listing, GPT-6.1 Terra sits at 48 with a cost per task of $0.40. GPT-6.1 Sol is at 52 and $0.72. GPT-5.6 Terra is at 42 and $1.40. GPT-6 Astra is at 53 with a much higher per-token price, and GPT-6 Luna is at 38 and cheaper still.

The useful read is not "Terra is 71% cheaper per task than its predecessor" — true, but that is a comparison against a model you were already leaving. It is that Terra's $0.40 sits between Sol's $0.72 and Luna's sub-ten-cent territory, which puts the decision on a line: is the task hard enough that four index points change the outcome? For form-filling, invoice extraction and screenshot triage, no. For long-horizon coding, yes.

One number from the launch is worth re-reading in this light. OpenAI's own comparison puts GPT-6.1 Terra at maximum effort roughly level with GPT-6 Astra at medium on Agents' Last Exam, at about one-tenth the per-token price. That is a per-task claim wearing a per-token costume, and it is the strongest cost argument in the release — stronger than "half price," because it accounts for how many tokens each model burns.

What you can actually buy today

GPT-6.1 Terra is not on the OrcaRouter catalogue at the time of writing. The catalogue carries GPT-6.1 Sol at $2/$10, GPT-5.6 Terra at $2/$12, GPT-6 Astra at $10/$50 and GPT-6 Luna at $0.10/$0.50, at 0% markup over provider list price, but not the new Terra. Anyone quoting you a Terra rate through a router today is either ahead of the vendor's documentation or guessing.

That leaves a practical shape for the next few weeks. Price the workload on the arms you can call right now — Sol and Luna are both live, on one key, with automatic failover — and trial Terra directly against OpenAI's API in parallel. Because our catalogue passes provider list price through with no markup, a vendor price cut shows up on the Sol and Luna arms the same day OpenAI publishes it; nothing has to be renegotiated. If Terra later lands in the catalogue, the migration is a model string, and the measurement you built on the Sol arm is the baseline you compare it against.

A budget template that survives contact

• Separate input, cached input, output and cache writes. Four lines, not one.

• Flag every request above 272K tokens. If more than a few percent cross it, re-price the whole workload at the long-context tier, not the headline tier.

• Price effort separately. Run the same eval at low, medium and max; the token count, not the rate, is what moves.

• Model retries. A browser agent with a 30% retry rate costs 30% more per task than the arithmetic suggests, and the cheap model is usually the one that needs the retry.

• Compare cost per finished task, not cost per million. The index-task number from Artificial Analysis is a reasonable proxy when you have nothing better; your own eval is better.

The half-price headline is real. It is also the least interesting number on the card, because it describes a rate rather than a bill. The bill is set by effort, by the 272K cliff, by how often you rebuild a cache, and by how many attempts a task takes — and on three of those four, OpenAI's own documentation gives you the dial but not the setting.