GPT 6.1 Terra API Cost: A Reproducible Cache Evaluation
Estimate GPT 6.1 Terra API costs with explicit token assumptions, published OneMux and official prices, and a repeatable test for whether prompt caching helps your workload.
Summary · TL;DR
A practical cost-estimation guide for GPT 6.1 Terra. It separates input, output, cache-write, and cache-read costs, explains the 272K pricing tier, and gives an explicit test plan for measuring repeatable workloads.
Key Takeaways
- Estimate input, output, cache writes, and cache reads separately; do not compare prices with different units or tiers.
- At the listed ≤272K rates, a stable prefix used twice already costs less with caching than without it, assuming each reuse is a cache read.
- Prompts that change early in the request may not reuse a cached prefix, so test with the exact prompt structure and limits you expect to deploy.
- The OneMux published price snapshot is dated 2026-11-10; check current prices and applicable tier conditions before estimating a live workload.
On this page (8)
GPT 6.1 Terra cost estimates depend on more than the number of requests. Input length, generated output, cache reuse, and the 272K input-token tier all affect the total. This guide gives a repeatable way to estimate those costs before deployment. The examples are illustrative calculations, not measured results.
GPT 6.1 Terra published prices
OneMux is the publisher of this comparison and provides access to GPT 6.1 Terra through a unified API. The table shows published per-million-token prices captured on 2026-11-10. The OneMux price ratio is 0.156 of the corresponding official price, or 84.4% lower by arithmetic; this is a published price comparison, not a guarantee of savings on any particular workload.
| Input tier and charge | Official price per 1M tokens | OneMux price per 1M tokens |
|---|---|---|
| Input, ≤272K | $1.00 | $0.156 |
| Output, ≤272K | $5.00 | $0.78 |
| Cache read, ≤272K | $0.05 | $0.0078 |
| Cache write, 30 minutes, ≤272K | $1.25 | $0.195 |
| Cache write, 12 hours, ≤272K | $2.50 | $0.39 |
| Input, >272K | $2.00 | $0.312 |
| Output, >272K | $7.50 | $1.17 |
| Cache read, >272K | $0.10 | $0.0156 |
| Cache write, 30 minutes, >272K | $2.50 | $0.39 |
| Cache write, 12 hours, >272K | $5.00 | $0.78 |
These are per-million-token rates, not per-request charges. The catalogue lists a 1M context, but the applicable price tier changes above 272K input tokens. For a real estimate, verify how the provider applies tiers to the request and which cache retention period applies. See the GPT 6.1 Terra model page and OneMux pricing for current published information.
Calculate a workload without caching
For each request, estimate input and output tokens separately:
Cost = input tokens ÷ 1,000,000 × input price + output tokens ÷ 1,000,000 × output price.
Then multiply by request count. Keep all assumptions visible: average tokens per request, number of requests, and whether the input crosses the 272K tier. For example, 10,000 requests with a 50,000-token input and a 500-token output each stay within the ≤272K tier. At OneMux published prices, the estimated input is 10,000 × 50,000 ÷ 1,000,000 × $0.156 = $78. Output is 10,000 × 500 ÷ 1,000,000 × $0.78 = $3.90. The total estimate is $81.90, before any other charges or differences between assumed and actual token counts.
Add cache writes and reads
Caching changes the input calculation. A cache write is charged at its write rate; each cache read uses the lower read rate. Do not count the same prefix as a read unless the workload actually reuses a matching prefix.
For a 50,000-token prefix used across 10,000 requests, assume one 30-minute cache write and 9,999 cache reads, all within the ≤272K tier. The OneMux estimate is:
- Write: 50,000 ÷ 1,000,000 × $0.195 = $0.00975.
- Reads: 9,999 × 50,000 ÷ 1,000,000 × $0.0078 = $3.89961.
- Total prefix cost: about $3.91, compared with $78 for sending that prefix as uncached input on all 10,000 requests.
This illustration holds prefix size constant and excludes output and any changing, uncached input. It assumes the provider records one write and the remaining requests qualify as reads. Actual cache behavior should be confirmed with your own request logs and provider billing records.
At these ≤272K rates, each cache read saves $0.1482 per million tokens versus standard input, while a 30-minute write costs $0.195 per million. The break-even is $0.195 ÷ $0.1482, or about 1.32 reads per write. In this simplified comparison, two reads recover the write cost. For a 12-hour write at $0.39 per million, break-even is about 2.63 reads, so three reads recover it. This arithmetic does not account for cache misses or prefixes that change between requests.
Test repeatability before relying on the estimate
Use a small evaluation set that represents the workload you intend to run, not a hand-picked prompt that always hits cache. Record the following for every test case:
- The exact prompt and tool definitions, including their order.
- Input and output token counts, request count, and expected request spacing.
- Whether the prefix is identical, changes once, or changes on every request.
- The cache retention assumption: 30 minutes or 12 hours.
- The expected tier and the calculated cost, separated into writes, reads, uncached input, and output.
Run each case with identical inputs first, then introduce realistic changes such as a user-specific instruction or retrieved document. Compare estimated costs with provider-reported usage. A timestamp, request identifier, reordered tool list, or changing content near the start can make a supposedly reusable prefix different. Treat cache-read share as an observed result, not an assumption. This protocol is a proposed evaluation method; no OneMux integration test or paid model evaluation is claimed here.
Watch the 272K boundary
The source article describes a price step above 272,000 input tokens: official standard input rises from $1 to $2 per million, and cache-read price rises from $0.05 to $0.10. The supplied OneMux catalogue similarly lists higher rates in the >272K tier. A workload near that boundary should be estimated using both the token count and the applicable tier, rather than extrapolating the lower rate.
A practical test should include one case just below the boundary and one above it, with otherwise equivalent prompts. If you can shorten stable boilerplate or retrieve only relevant document sections without changing the task, recalculate using the reduced input size. Whether that is acceptable depends on the task; do not assume that a shorter prompt preserves results.
Decision checklist
- Is the prefix actually stable across requests?
- How many cache reads are expected per write within the selected retention period?
- Are any requests above 272K input tokens?
- Have output tokens been estimated separately?
- Does the test set include realistic cache misses and changing prompts?
- Are the prices current, and are the billing units comparable?
GPT 6.1 Terra cost estimates become useful when these assumptions are explicit. Re-run the arithmetic with current prices and measured token counts before using it for a budget or product decision.
Sources
- OrcaRouter, “GPT-6.1 Terra Caching: Five Cents per Read—and When the Write Pays Off” — source for the cache pricing explanation, break-even discussion, prompt stability caveats, and 272K threshold context.
- OneMux GPT 6.1 Terra model page — published model prices used in the table; snapshot dated 2026-11-10.
Published price snapshot
Captured 2026-11-10T15:30:05.721Z from the OneMux published catalogue. Prices retain website billing units; this is not a live benchmark. Tiered, cached or time-based billing may differ. Unknown values are not zero.
| Model | Official input | Official output | OneMux input | OneMux output | Published price ratio |
|---|---|---|---|---|---|
| GPT 6.1 Terra | $1 | $5 | $0.156 | $0.78 | 0.156 |
Current OneMux prices. Compare workload costs only when input/output and billing units match; see each model page for tier conditions.
FAQ
How much does GPT 6.1 Terra input cost through OneMux?
The published OneMux catalogue snapshot dated 2026-11-10 lists input at $0.156 per million tokens at ≤272K and $0.312 per million above 272K. Prices can change, so check the model page for current terms.
When does GPT 6.1 Terra prompt caching break even?
At the ≤272K OneMux 30-minute rates, a cache write costs $0.195 per million tokens and each cache read costs $0.0078, compared with $0.156 for standard input. In the simplified case of one write followed by reads of the same prefix, break-even is about 1.32 reads; two reads recover the write cost.
Does caching always lower GPT 6.1 Terra costs?
No. Caching depends on eligible prefix reuse. If prompts change early or a request misses the cache, write costs may not be recovered. Measure cache reads and writes with representative prompts before projecting savings.
What changes above 272K input tokens?
The published catalogue lists higher input, output, cache-read, and cache-write rates above 272K. Confirm how the tier applies to your request and calculate using the applicable rates rather than the ≤272K prices.
Related articles
Guides
GPT 6.1 Terra API costs for support triage: a reproducible estimate
Estimate GPT 6.1 Terra API costs for human-approved support triage using explicit token volumes, cache assumptions, and comparable official and OneMux rates.
Guides
Estimate GPT 6.1 Terra API Costs for Document Q&A
A reproducible way to estimate GPT 6.1 Terra costs for document question answering with source attribution, including cache assumptions and the long-context tier.
Guides
GPT 6.1 Terra API Cost Estimates for Privacy-Aware Workloads
Estimate GPT 6.1 Terra API costs with explicit token, cache and context-tier assumptions—and reduce exposure of user data and credentials.
Guides
GPT Image 2.5 Sunburst API Cost: A Reproducible Estimate for Privacy-Aware Workloads
Estimate GPT Image 2.5 Sunburst API costs using explicit token assumptions, monthly workload arithmetic, and practical safeguards for user data and credentials.