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.
Summary · TL;DR
An illustrative 10,000-ticket workload costs $36.66 at published OneMux rates without caching, or $7.3944 under a specified cache-write and reuse pattern. Both estimates exclude human review and other operating costs.
Key Takeaways
- At the November 12, 2026 snapshot, GPT 6.1 Terra's published OneMux input and output price ratio was 0.156 relative to official rates in both context tiers.
- A 10,000-ticket example with a 20,000-token shared prefix, 2,000 variable input tokens, and 300 output tokens per ticket costs $36.66 without caching at OneMux rates.
- Under an explicitly assumed pattern of 100 cache writes and 9,900 reads, the same workload costs $7.3944 at OneMux rates; actual savings depend on billing and cache reuse.
- Human approval remains a separate workflow and cost: the model proposes a category, priority, and draft; a reviewer decides whether to act.
On this page (9)
The estimate at a glance
For an illustrative 10,000-ticket support-triage workload, GPT 6.1 Terra costs $36.66 in API tokens at the published OneMux rates without caching. With 100 short-retention cache writes and 9,900 subsequent reads of a shared policy prefix, the estimate falls to $7.3944. At the corresponding official rates, the estimates are $235 and $47.40.
These are calculations, not test results or quotes. They exclude reviewer time, retries, storage, retrieval, and other operating costs. OneMux, the publisher of this article, is the product discussed in the comparison. Before budgeting, verify current rates and how your chosen endpoint accounts for cache writes and reads.
Price snapshot and billing units
The following GPT 6.1 Terra catalogue snapshot was captured on November 12, 2026. All amounts are US dollars per million tokens. The published ratio is the OneMux price divided by the official price; 0.156 corresponds to an 84.4% difference in these listed token rates, not a guarantee of total-bill savings.
| Input context tier | Official input | Official output | OneMux input | OneMux output | Published price ratio |
|---|---|---|---|---|---|
| ≤272K | $1 | $5 | $0.156 | $0.78 | 0.156 |
| >272K | $2 | $7.50 | $0.312 | $1.17 | 0.156 |
Cache rates also depend on the context tier and retention option:
| Input context tier | Provider and rates | Cache read | 30-minute cache write | 12-hour cache write |
|---|---|---|---|---|
| ≤272K | Official | $0.05 | $1.25 | $2.50 |
| ≤272K | OneMux | $0.0078 | $0.195 | $0.39 |
| >272K | Official | $0.10 | $2.50 | $5 |
| >272K | OneMux | $0.0156 | $0.39 | $0.78 |
The cache-write durations are retention options, not promises that a particular request will hit the cache. The external OrcaRouter caching article describes the official cache rates, stable-prefix reuse, and the higher input and cache rates above 272,000 input tokens. The OneMux snapshot supplies the OneMux rates and both output tiers. Check the applicable endpoint's current tier and cache-billing rules before applying them to an invoice.
Define the support-triage workload
Assume one model call per ticket. The model receives a shared support policy and the ticket, then returns a proposed category, priority, short rationale, and response draft. A human reviews the proposal before any response or consequential action. The example does not assume the model can safely make those decisions unaided.
| Assumption | Illustrative value |
|---|---|
| Tickets and model calls | 10,000 |
| Stable policy prefix per call | 20,000 input tokens |
| Ticket-specific content per call | 2,000 input tokens |
| Generated triage and draft per call | 300 output tokens |
| Input tokens per call | 22,000; within the ≤272K tier |
For caching, additionally assume the workload produces 100 distinct cache-write events, each followed by 99 successful reads of the same prefix within the 30-minute retention window. This is a deliberately high-reuse scenario, not an expected hit rate. The first call in each group is billed for a write instead of a standard input charge or a read for that prefix. Ticket-specific tokens are always billed as ordinary input. No extra prefix tokens are charged beyond the writes and reads shown.
Those billing assumptions matter: if the endpoint charges differently, if the prefix changes, or if the 99 reads do not occur within retention, this estimate will not match the bill.
Calculate uncached and cached costs
Without caching, the 10,000 calls contain 220 million input tokens and 3 million output tokens. At OneMux rates, that is 220 × $0.156 = $34.32 for input and 3 × $0.78 = $2.34 for output, or $36.66 total. At official rates, the same volumes cost 220 × $1 + 3 × $5 = $235.
For the cached case, calculate each token category separately. The table shows millions of tokens so that each volume can be multiplied directly by its per-million rate.
| Token category | Volume in millions | OneMux calculation | Official calculation |
|---|---|---|---|
| Variable ticket input | 20 | 20 × $0.156 = $3.12 | 20 × $1 = $20 |
| Prefix writes: 100 × 20,000 | 2 | 2 × $0.195 = $0.39 | 2 × $1.25 = $2.50 |
| Prefix reads: 9,900 × 20,000 | 198 | 198 × $0.0078 = $1.5444 | 198 × $0.05 = $9.90 |
| Output | 3 | 3 × $0.78 = $2.34 | 3 × $5 = $15 |
| Total | $7.3944 | $47.40 |
On these assumptions, caching reduces the OneMux token estimate by $29.2656, or about 79.8%, compared with the uncached example. It does not reduce the assumed ticket-specific input or output volumes. A real support operation should budget separately for human approval, rejected drafts, escalation, retries, and any subsequent model calls.
Decide whether caching is worth testing
Under the example's accounting convention, a 30-minute write replaces the first ordinary prefix input charge. At official ≤272K rates, one million prefix tokens cost $1.25 to write and $0.05 for one later read, versus $2 for two ordinary inputs. Thus one subsequent read makes this particular two-call sequence cheaper. For a 12-hour write, $2.50 plus two $0.05 reads is $2.60, versus $3 for three ordinary inputs: two subsequent reads are needed. The OneMux rates have the same break-even counts because the listed rates share the same ratio.
This differs from counting a write as an additional charge on top of every read, as in the illustrative convention used by the OrcaRouter article. Confirm which convention applies to your endpoint; do not assume the break-even count without checking usage records.
To make reuse plausible, keep the policy and stable instructions in the same order and put ticket-specific text, identifiers, and timestamps after them. Changing early instructions, tool definitions, document order, or formatting can prevent a prefix match. Do not log raw customer tickets merely to diagnose reuse: compare privacy-safe prompt-version identifiers and cache-usage totals instead.
If the policy changes frequently or traffic is too sparse for reuse within retention, use the uncached estimate as the safer starting point. Also measure whether the entire policy is necessary: a shorter, relevant policy excerpt may reduce input cost without relying on cache hits, though its effect on triage quality needs review.
Validate cost and keep the reviewer in control
Before rollout, sample representative tickets and compare the model's proposed category, priority, and draft with human decisions. Record disagreements and escalations; no accuracy or latency result is established by the price catalogue. Keep the approval step explicit in the application: the model's output is a proposal, and the reviewer can edit, reject, or escalate it before a response is sent.
For a cost check, record input tokens, output tokens, cache-write tokens, cache-read tokens, request counts, and applicable tiers from actual usage reports. Recalculate the table with observed averages and include additional calls for retries or revisions. Watch the 272K input threshold: the published higher tier changes both input and output rates as well as cache rates, so a workload near the boundary deserves a separate estimate.
OneMux provides access to models through an OpenAI-compatible API and offers spend visibility; endpoint and parameter compatibility, including cache behavior, should be verified against current documentation. Direct provider access is an alternative. Compare the same token volumes, retention assumptions, review workflow, and service terms before choosing either route.
Conclusion
For support triage, the useful budget is not a per-token price in isolation: it is the cost of a reviewed ticket at an observed input size, output size, and cache reuse rate. Start with the uncached calculation, validate whether the shared prefix actually produces reads, and add human and retry costs before setting a production budget.
Sources
- OneMux: GPT 6.1 Terra model catalogue — published price and tier snapshot captured November 12, 2026; prices may change.
- OrcaRouter: GPT-6.1 Terra caching — supplied source for official caching prices, reuse considerations, and the long-context threshold.
Published price snapshot
Captured 2026-11-12T15:30:05.422Z 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 cost for 10,000 support tickets?
In the illustrative workload, 22,000 input tokens and 300 output tokens per ticket cost $36.66 without caching at the November 12, 2026 OneMux snapshot rates. A specified high-reuse cache scenario costs $7.3944. Neither figure includes human review or other operating costs.
Does a cache write always save money?
No. Savings depend on the write charge, subsequent matching reads, retention period, and actual billing treatment. A prefix that changes or is not reused within retention may cost more to write than to send as ordinary input.
Does the estimate include human approval?
The workflow assumes a human approves or edits the model's proposal, but the dollar estimates cover model token charges only. Reviewer labor and escalation costs must be added separately.
Related articles
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.
Guides
GPT 6.2 Astra API cost estimate for support triage with human approval
Estimate GPT 6.2 Astra token costs for a human-approved customer support triage workflow, with tier and cache examples.
Guides
GPT Image 2.5 API costs for customer support triage
Estimate GPT Image 2.5 image-generation costs for support triage using explicit token assumptions, approval rates, and reproducible calculations.
Guides
Qwen4 Max API Costs for Customer Support Triage: A Reproducible Estimate
Estimate Qwen4 Max API and human-review costs for a support triage workload, with explicit token assumptions, retry costs, and cache examples.