GuidesOneMux

GPT 6.1 Terra API Costs for Production Workflows: A Retry and Cache Budget

Estimate GPT 6.1 Terra API costs per completed workflow, including retries, cache writes, recovery rules, and context-tier changes.

AI

Summary · TL;DR

A reproducible cost model for GPT 6.1 Terra production workflows, with an illustrative retry and cache budget, tier analysis, and recovery checklist.

Key Takeaways

  • Budget per completed workflow, not just per API request: retries, recovery calls, output tokens, and cache rewrites all affect the result.
  • In the illustrative 10,000-workflow example, the estimated cached API cost is $110.75 at official rates or $17.277 at published OneMux rates, before other service costs.
  • The cache break-even calculation depends on how writes and reads are billed; verify actual usage records before applying the example to production.
  • A request crossing 272,000 input tokens can move into a higher pricing tier, so track the complete request size rather than the stable prefix alone.
On this page (9)

Start with cost per completed workflow

For a production workflow using GPT 6.1 Terra, estimate the cost of all attempts needed to complete a job, not just the first request. Include retry input and output, cache writes after expiry or prompt changes, and any recovery calls. Then divide the total by completed jobs.

The illustrative workload below costs $110.75 at the listed official rates or $17.277 at OneMux rates for 10,000 completed jobs, under the stated cache accounting assumptions. Those are API token estimates, not observed bills. Actual cost depends on provider billing semantics, cache hits, failures and request sizes.

OneMux is the publisher of this guide and provides access to models through an OpenAI-compatible API. The same estimation method is useful when evaluating a direct provider connection or another route.

GPT 6.1 Terra price snapshot

The OneMux model catalogue snapshot was captured on November 13, 2026. All prices below are US dollars per million tokens. The published OneMux-to-official price ratio is 0.156, equivalent to an 84.4% discount, for the listed input and output prices in both tiers. These are published prices, not a guarantee of the eventual invoice; check current prices before budgeting.

Input context tierOfficial inputOfficial outputOneMux inputOneMux outputPublished price ratio
≤272K tokens$1.00$5.00$0.156$0.780.156
>272K tokens$2.00$7.50$0.312$1.170.156

Cache prices also vary by tier, retention period and route:

Input context tierOfficial cache readOfficial write, 30 minOfficial write, 12 hOneMux cache readOneMux write, 30 minOneMux write, 12 h
≤272K tokens$0.05$1.25$2.50$0.0078$0.195$0.39
>272K tokens$0.10$2.50$5.00$0.0156$0.39$0.78

OrcaRouter's caching analysis describes the official cache rates and the 272K threshold. Its examples treat a cache write as a separate charge followed by paid reads. Use that convention only as an estimation assumption here: confirm the route's actual write, read and initial-request accounting in its documentation and usage records. Do not assume that a cache was hit merely because a prompt looked reusable.

Worked example: 10,000 jobs with retries

Assume a workflow processes 10,000 jobs in one accounting period. Every job completes. The workload uses the lower context tier and has:

  • 11,000 total attempts: 10,000 initial attempts plus 1,000 retries. Each attempt sends the full input and produces the assumed output, including unsuccessful attempts.
  • 50,000 stable prefix tokens and 2,000 variable input tokens per attempt.
  • 1,000 output tokens per attempt.
  • 100 writes of the stable prefix at the 30-minute write rate, plus 11,000 cache reads of that prefix. This is an illustrative billing convention, not a claim about observed cache behavior.
  • No separate recovery calls, tool charges, taxes or infrastructure costs. The cost of generating or retrieving input outside the model API is excluded.

The 100 writes represent expiry or replacement across the period. They are not one write per job. The 1,000 retries represent 10% of initial jobs, not a measured failure rate for the model.

Cost componentToken arithmeticOfficial costOneMux cost
Prefix writes100 × 50,000 = 5 million tokens5 × $1.25 = $6.255 × $0.195 = $0.975
Prefix reads11,000 × 50,000 = 550 million tokens550 × $0.05 = $27.50550 × $0.0078 = $4.29
Variable input11,000 × 2,000 = 22 million tokens22 × $1.00 = $22.0022 × $0.156 = $3.432
Output11,000 × 1,000 = 11 million tokens11 × $5.00 = $55.0011 × $0.78 = $8.58
Total10,000 completed jobs$110.75$17.277

That is $0.011075 per completed job at official rates and $0.0017277 at OneMux rates. For an apples-to-apples uncached comparison, the same attempts send 572 million ordinary input tokens and produce 11 million output tokens: $627.00 official or $97.812 OneMux. These estimates hold the job count, attempts and output constant; they do not establish the cache savings a real workload will achieve.

When a cache write pays for itself

Under the example's write-plus-read convention, each million prefix tokens read at the lower official tier saves $0.95 versus ordinary input: $1.00 minus $0.05. A 30-minute write costs $1.25 per million, so two reads save $1.90 and exceed that write cost. A 12-hour write costs $2.50, so three reads save $2.85 and exceed it.

This break-even applies per stable prefix and retention window. It excludes variable input and output because they are assumed unchanged. If the initial write is billed differently, or a request only partially matches the cached prefix, recalculate using actual billed usage. The source analysis also warns that changing early prompt content can prevent reuse.

Keep stable instructions, tool definitions and documents in a consistent order; put request IDs, timestamps and job-specific material after them where the API's documented cache behavior permits. Measure hit and write rates rather than treating this prompt layout as a guarantee.

Set retry and recovery rules before forecasting

A retry can repeat token charges and, more importantly, repeat an external action. Make the workflow policy explicit:

  1. Classify the failure. Retry transient transport or rate-limit failures with bounded backoff; route invalid requests or failed validation to correction or review rather than retrying unchanged indefinitely.
  2. Set an attempt limit and a cost ceiling. Budget the maximum permitted attempts as well as the average. A timeout may still have generated billable output, so reconcile against usage records rather than assuming it was free.
  3. Protect side effects. Use an application-level idempotency key or durable job state before retrying an operation that can send a message, change a record or invoke a tool. Check whether the action already completed after an ambiguous timeout.
  4. Account for recovery separately. A repair prompt, human-review preparation call or fallback model call is an additional attempt with its own input, output and price. The worked example assumes none; add them when present.
  5. Record the denominator. Track completed jobs, failed jobs, attempts, billed input and output, cache reads and writes, and cost by tier. A low cost per attempt can hide a high cost per completion.

Watch the 272K threshold

The tier is described in terms of input context, so inspect the whole request, including variable material—not just the reusable prefix. At the listed official rates, 270,000 uncached input tokens cost $0.27, while 273,000 at the higher rate cost $0.546, assuming the higher rate applies to the full input as in the source's examples. Output rates also change by tier. Verify the applicable billing treatment before relying on a boundary estimate.

For jobs near the threshold, remove unnecessary context or retrieve a smaller relevant section, then check task quality. A smaller prompt is only an operational improvement if the workflow still completes reliably; additional retries can erase an apparent saving.

Conclusion

Start with an attempt distribution, realistic token counts and cache-write frequency; calculate both ordinary and cached input; then divide by completed jobs. Treat the result as a forecast until usage records confirm cache accounting, tier selection and the cost of failed attempts.

Sources

Published price snapshot

Captured 2026-11-13T19:30:05.480Z 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 should retries be included in GPT 6.1 Terra cost estimates?

Count the input and output of every attempt, including failed attempts when billed, and add any separate recovery calls. Divide total cost by completed jobs, not attempts.

When does a GPT 6.1 Terra cache write break even?

At the listed lower-tier official prices, assuming a separate write charge followed by paid reads, a 30-minute write breaks even after two full reads and a 12-hour write after three. Actual billing and cache matching must be verified.

Does the 272K tier depend only on the cached prefix?

The tier is described by input context, so estimate using the complete request, including variable input. Confirm the provider's tier application in billing documentation and usage records.

Related articles