GPT 6.2 Astra API cost estimate for document question answering
Estimate GPT 6.2 Astra document question-answering costs using explicit token assumptions, context tiers, cache rates, and reproducible arithmetic.
Summary · TL;DR
An illustrative cost model for source-attributed document answers, including official and OneMux token prices, cache economics, and a checklist for replacing assumptions with observed usage.
Key Takeaways
- At 12,000 input and 1,000 output tokens per answer, the illustrative Astra cost is $0.136 at the listed official rates or $0.014144 at the OneMux snapshot rates.
- For 10,000 answers with the same token mix, those estimates become $1,360 and $141.44 respectively, before retrieval, ingestion, retries, and other costs.
- Requests over 272K input tokens have higher listed input and output rates; estimate them separately rather than applying one blended rate.
- Cache savings depend on actual eligible writes and reads, retention, and billing behavior—not simply on repeated document content.
On this page (8)
For document question answering with source attribution, budget for the evidence sent to the model as well as the answer it returns. In an illustrative workload of 12,000 input tokens and 1,000 output tokens per answer, GPT 6.2 Astra costs $0.136 per answer at the listed official rates, or $0.014144 at the OneMux snapshot rates, before retrieval and other expenses.
This is a pricing scenario, not a measured result. OneMux, the publisher of this article, is also the product in the price comparison. Actual costs depend on token usage, cache eligibility, request size, and the rates in effect when you run the workload.
Prices and units to use
The following OneMux catalogue snapshot was captured on November 18, 2026. All prices are US dollars per 1 million tokens. The published price ratio is OneMux price divided by the listed official price; it is not a percentage discount. A ratio of 0.104 corresponds arithmetically to a 89.6% lower token rate for the prices shown, not a guarantee of equivalent total workload savings.
| Input context tier | Official input | Official output | OneMux input | OneMux output | Published price ratio |
|---|---|---|---|---|---|
| Up to and including 272K tokens | $8 | $40 | $0.832 | $4.16 | 0.104 |
| Over 272K tokens | $16 | $60 | $1.664 | $6.24 | 0.104 |
The supplied gateway changelog also reports the $8/$40 standard Astra rates and $16/$60 rates for prompts over 272K input tokens. Check current provider terms and OneMux pricing before committing a budget. The tier is determined per request, so keep long-context requests separate in your estimate. Do not assume that a large context window makes sending an entire document collection economical.
Estimate the cost of one attributed answer
Assume a retrieval step selects relevant document passages, and the model receives those passages alongside the question and citation instructions. For this example:
- Each request uses 12,000 input tokens, including the question, instructions, document excerpts, and source identifiers.
- Each response uses 1,000 billable output tokens, including the answer, citations, and any billable reasoning tokens. The gateway source says reasoning tokens bill as output; do not count them again if they are already included in the output total.
- Every request falls in the up-to-272K tier. There are no cache reads or writes, retries, or failed requests in this baseline.
- The workload produces 10,000 answers in a month. This is an assumption, not a traffic forecast.
Calculate each token category separately, divide its token count by one million, and multiply by its matching rate.
| Cost component | Official calculation | Official cost | OneMux calculation | OneMux cost |
|---|---|---|---|---|
| Input per answer | 12,000 ÷ 1,000,000 × $8 | $0.096 | 12,000 ÷ 1,000,000 × $0.832 | $0.009984 |
| Output per answer | 1,000 ÷ 1,000,000 × $40 | $0.040 | 1,000 ÷ 1,000,000 × $4.16 | $0.004160 |
| Total per answer | $0.096 + $0.040 | $0.136 | $0.009984 + $0.004160 | $0.014144 |
| 10,000 answers | 10,000 × $0.136 | $1,360 | 10,000 × $0.014144 | $141.44 |
The estimate covers model tokens only. Add document parsing, embeddings, indexing, retrieval, storage, application hosting, evaluation, and any billed retries separately. Their prices are not supplied here; they are not zero. Taxes and other applicable charges are also outside the example.
What if a request exceeds 272K input tokens?
For a separate illustrative request with 300,000 input tokens and 1,000 output tokens, applying the listed over-272K rates to those quantities gives:
| Price basis | Input cost | Output cost | Total per answer |
|---|---|---|---|
| Official | 300,000 ÷ 1,000,000 × $16 = $4.80 | 1,000 ÷ 1,000,000 × $60 = $0.06 | $4.86 |
| OneMux | 300,000 ÷ 1,000,000 × $1.664 = $0.4992 | 1,000 ÷ 1,000,000 × $6.24 = $0.00624 | $0.50544 |
This scenario assumes the higher tier applies to all the input and output tokens in the request. Confirm the applicable billing rules for your account. It is not an apples-to-apples quality comparison with the shorter request: the evidence supplied to the model is different.
Account for cache writes and reads
Repeated questions about the same documents may reuse a cacheable prompt prefix, but repetition alone does not establish a cache hit. The catalogue lists these Astra cache rates per million tokens; the write columns distinguish the listed retention periods.
| Input context tier | Official cache read | Official write, 30 minutes | Official write, 12 hours | OneMux cache read | OneMux write, 30 minutes | OneMux write, 12 hours |
|---|---|---|---|---|---|---|
| Up to and including 272K | $0.40 | $10 | $20 | $0.0416 | $1.04 | $2.08 |
| Over 272K | $0.80 | $20 | $40 | $0.0832 | $2.08 | $4.16 |
For an illustrative standard-tier batch, suppose 10,000 tokens are billed once as a 30-minute cache write and then billed as cache reads on nine subsequent requests. Counting only that shared portion, the official cost is $0.10 for the write plus $0.036 for the nine reads, or $0.136. The equivalent OneMux calculation is $0.0104 plus $0.003744, or $0.014144. Without caching, ten ordinary input charges for that same 10,000-token portion would be $0.80 official or $0.0832 OneMux.
This is a category-by-category illustration, not a promise that those ten requests qualify. It assumes the cache-write rate replaces the ordinary input charge for the written portion, each later use is billed as a read, and all reads occur within the applicable retention period. Confirm actual eligibility, accounting, and retention rules. Add non-cached input and all output separately; do not count the same tokens as both ordinary input and cache input unless your billing terms require it.
Turn the estimate into a budget you can audit
- Define a successful answer. Require citations to stable document identifiers and passages that support each material claim. An answer with a citation is not automatically grounded; review whether the cited passage actually supports it.
- Measure a representative sample. Record input, output, cache reads and writes, request tier, and billed cost where available. Include short and long documents, unanswerable questions, and questions spanning multiple sources. No paid evaluation was run for this article.
- Track cost per accepted answer. Divide total billed workload cost—including retries and failed attempts—by answers that pass your attribution check. This reveals costs hidden by a per-request average.
- Investigate outliers. Large retrieved passages, repeated instructions, verbose citations, and long outputs can increase token usage. Check that source identifiers are preserved when passages are truncated or reordered.
- Recalculate by tier and cache category. Multiply observed token totals by their matching current rates, then add non-model expenses. Treat unavailable usage or prices as unknown rather than zero.
When to consider an alternative
If the citation-quality target can be met with less context or a different model, test that on your own document set before choosing solely by token price. The supplied gateway changelog reports that GPT 6.2 Sol and Astra both solved a small rate-limiter example in five runs, with Sol costing less in that example. That result does not establish their relative accuracy or cost per accepted answer for document Q&A; those results are unknown without a relevant evaluation.
For a first budget, use the baseline calculation, then replace every token and success-rate assumption with observed data. Separate long-context and cached traffic so that a plausible average does not hide an expensive request mix.
Sources
- GPT-6.2 Astra and GPT-6.2 Sol in AI Gateway — reported model rates, context-tier threshold, reasoning-token billing, and the limited rate-limiter example.
- OneMux GPT 6.2 Astra model page — catalogue price snapshot and tiered rates; prices may change.
- OneMux pricing — check current published pricing before estimating a live workload.
Published price snapshot
Captured 2026-11-18T08:00:05.571Z 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.2 Astra | $8 | $40 | $0.832 | $4.16 | 0.104 |
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.2 Astra cost per document answer?
With 12,000 input tokens and 1,000 output tokens, no caching, and the up-to-272K snapshot rates, the illustrative model-token cost is $0.136 at listed official rates or $0.014144 at OneMux rates. Retrieval, ingestion, retries, and other expenses are excluded.
Do citations have a separate token price?
The supplied pricing does not list a separate citation charge. Citation instructions and source identifiers contribute to input tokens, while citations generated in an answer contribute to output tokens.
Does repeating a document guarantee a cache discount?
No. Savings depend on whether the repeated content qualifies for caching, the billed write and read categories, retention, and the applicable terms. Measure actual cache usage rather than assuming every repetition is a hit.
How should long-context requests be budgeted?
Estimate requests over 272K input tokens separately using the applicable higher-tier rates. Confirm how those rates apply to the full request and include any cache categories and output tokens.
Related articles
Guides
Estimate Claude Fable 5.2 API Costs for Document Q&A
A reproducible way to estimate Claude Fable 5.2 costs for document question answering, with explicit token assumptions, source-attribution guidance, and dated price figures.
Guides
Qwen3.7 Plus API cost for document question answering
Estimate Qwen3.7 Plus API costs for document question answering with source attribution, using explicit token assumptions and reproducible arithmetic.
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.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.