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.
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 tier | Official input | Official output | OneMux input | OneMux output | Published price ratio |
|---|---|---|---|---|---|
| ≤272K tokens | $1.00 | $5.00 | $0.156 | $0.78 | 0.156 |
| >272K tokens | $2.00 | $7.50 | $0.312 | $1.17 | 0.156 |
Cache prices also vary by tier, retention period and route:
| Input context tier | Official cache read | Official write, 30 min | Official write, 12 h | OneMux cache read | OneMux write, 30 min | OneMux 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 component | Token arithmetic | Official cost | OneMux cost |
|---|---|---|---|
| Prefix writes | 100 × 50,000 = 5 million tokens | 5 × $1.25 = $6.25 | 5 × $0.195 = $0.975 |
| Prefix reads | 11,000 × 50,000 = 550 million tokens | 550 × $0.05 = $27.50 | 550 × $0.0078 = $4.29 |
| Variable input | 11,000 × 2,000 = 22 million tokens | 22 × $1.00 = $22.00 | 22 × $0.156 = $3.432 |
| Output | 11,000 × 1,000 = 11 million tokens | 11 × $5.00 = $55.00 | 11 × $0.78 = $8.58 |
| Total | 10,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:
- 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.
- 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.
- 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.
- 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.
- 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
- OneMux GPT 6.1 Terra model listing and OneMux pricing — supplied catalogue snapshot captured November 13, 2026.
- OrcaRouter: GPT-6.1 Terra caching — supplied analysis of official cache rates, break-even assumptions and the long-context threshold.
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.
| 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 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
Guides
Gemini 4 Neon API Costs: A Workload Estimate With Retries and Recovery
Estimate Gemini 4 Neon production workflow costs using comparable token units, explicit retry assumptions, and a reproducible cost-per-success calculation.
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
GPT 6.1 Terra API Costs for Repository Changes and Test Verification
Estimate GPT 6.1 Terra token costs for a repository change and test-verification workflow, with explicit cache assumptions and reproducible arithmetic.
Guides
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.