GuidesOneMux

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.

AI

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 chargeOfficial price per 1M tokensOneMux 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:

  1. The exact prompt and tool definitions, including their order.
  2. Input and output token counts, request count, and expected request spacing.
  3. Whether the prefix is identical, changes once, or changes on every request.
  4. The cache retention assumption: 30 minutes or 12 hours.
  5. 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

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.

ModelOfficial inputOfficial outputOneMux inputOneMux outputPublished price ratio
GPT 6.1 Terra$1$5$0.156$0.780.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