The Rate Card Is Not the Bill: A Reproducible Cost Test for GPT-5.6, GPT-6 Astra, Claude Fable, Opus, and Gemini 3.8 Flash
Fact-checked against official provider documentation on September 13, 2026. No benchmark trials were conducted for this article.
A model with the lowest price per million tokens is not necessarily the least expensive model for a production task. Internal reasoning, invalid output, truncation, retries, cache behavior, tool use, service tier, and regional processing can all change the cost of obtaining one result that an application can actually accept.
The more defensible unit is therefore cost per accepted result:
cost per accepted result =
total billed cost of all attempts
÷
number of outputs that pass independent acceptance tests
That metric preserves the economic effect of failed requests rather than hiding them behind a headline token rate.
Key Takeaways
- All model families named in the original draft are real, but several labels require normalization: “6.0 Astra” is GPT-6 Astra, while “Fable 5.0” is Claude Fable 5.
- The retained comparison contains eight model configurations and two effort settings each: 16 conditions and 480 proposed requests at 30 trials per condition.
- OpenAI and Anthropic report reasoning or thinking as a detail inside an inclusive output-token total. Google’s
generateContentmetadata reports candidate and thought tokens separately.- OpenAI
max, Anthropicmax, and Googlehighare behavioral controls—not equivalent token budgets or standardized units of compute.- The benchmark below is a proposed validation protocol, not evidence of model quality, latency, or cost.
The Verified Model Set
OpenAI released the GPT-5.6 family on July 9, 2026 with Sol, Terra, and Luna tiers. The current API references use gpt-5.6-sol, gpt-5.6-terra, and gpt-5.6-luna; the unsuffixed gpt-5.6 alias routes to Sol. Each supports none, low, medium, high, xhigh, and max, with medium as the default. OpenAI’s launch announcement and individual Sol, Terra, and Luna references document those identifiers and settings.
GPT-6 Astra uses API ID gpt-6-astra. OpenAI announced it on September 3, 2026 as a staged rollout, initially to a limited set of organizations and then through the OpenAI API and supported cloud platforms. Its model reference supports low, medium, high, xhigh, and max, but not none; the documentation does not identify a universal default, so the benchmark must set effort explicitly and confirm account access before execution. OpenAI’s Astra announcement and model reference provide the authoritative status and API control surface.
Anthropic’s current documentation lists Claude Fable 5.1 as active latest, released September 1, 2026, and Claude Fable 5 as active legacy, released June 9, 2026. Their API IDs are claude-fable-5-1 and claude-fable-5. Both use always-on adaptive thinking and default to high effort. Fable 5.1 and Fable 5 each have a 1-million-token context window and 128,000-token maximum output.
Claude Opus 4.8 (claude-opus-4-8) is also verified, but it is now active legacy rather than Anthropic’s current Opus model. Anthropic records a May 28, 2026 release date, adaptive thinking, high default effort, a 1-million-token context window, and 128,000-token maximum output. For a controlled test, adaptive thinking should be enabled explicitly instead of relying on endpoint or client defaults. Anthropic’s Opus 4.8 reference documents its lifecycle and configuration.
Google lists Gemini 3.8 Flash (gemini-3.8-flash) as stable and generally available. It supports a 1-million-token context window, up to 64,000 output tokens, and low, medium, and high thinking levels; medium is the default and minimal is unsupported. Google’s current model and launch documentation does not expose a separate release-date field, so this article does not assign one. Google’s model catalog and Gemini 3.8 Flash guide provide the supported values.
Publication-Day API Pricing
The table below uses first-party, paid, synchronous Standard text API pricing in USD per 1 million tokens, checked September 13, 2026. OpenAI rows show short-context rates; Anthropic rows use global first-party inference; Google uses Paid Standard introductory pricing.
| Provider and model | Status | Proposed effort pair | Context / max output | Input | Cached read | Cache write or storage | Output |
|---|---|---|---|---|---|---|---|
GPT-5.6 Sol, gpt-5.6-sol |
GA | none, max |
1.05M / 128K | $4.00 | $0.40 | $5.00 write | $20.00 |
GPT-5.6 Terra, gpt-5.6-terra |
GA | none, max |
1.05M / 128K | $2.00 | $0.20 | $2.50 write | $12.00 |
GPT-5.6 Luna, gpt-5.6-luna |
GA | none, max |
1.05M / 128K | $0.20 | $0.02 | $0.25 write | $1.20 |
GPT-6 Astra, gpt-6-astra |
Staged rollout | low, max |
1.05M / 128K | $10.00 | $1.00 | $12.50 write | $50.00 |
Claude Fable 5, claude-fable-5 |
Active legacy | low, max |
1M / 128K | $10.00 | $1.00 | $12.50 5m / $20 1h | $50.00 |
Claude Fable 5.1, claude-fable-5-1 |
Active latest | low, max |
1M / 128K | $10.00 | $0.25 | $12.50 5m / $20 1h | $50.00 |
Claude Opus 4.8, claude-opus-4-8 |
Active legacy | low, max |
1M / 128K | $5.00 | $0.50 | $6.25 5m / $10 1h | $25.00 |
Gemini 3.8 Flash, gemini-3.8-flash |
GA | low, high |
1M / 64K | $0.75 | $0.075 | $0.50/MTok-hour storage | $3.75 |
OpenAI’s current API pricing table confirms the listed rates and states that GPT-5.6 Sol promotional pricing remains available at least through November 21, 2026. For requests above 272,000 input tokens, OpenAI charges twice the input, cached-input, and cache-write rates and 1.5 times the output rate for the full request. Regional-processing endpoints may add 10%, while Batch and Flex use different rates and Fast mode is priced at twice the applicable Standard rate.
Anthropic’s pricing documentation applies the listed rates across the full 1-million-token context window without a long-context uplift. US-only first-party inference applies a 1.1× multiplier to eligible models. Opus 4.8 Fast mode is a separate premium tier at $10 input and $50 output per million tokens; partner-operated cloud regions may carry their own pricing conditions.
Google’s Gemini API pricing page states that the Gemini 3.8 Flash rates above apply through December 31, 2026. On January 1, 2027, input becomes $1.50, cached content $0.15, output $7.50, and cache storage $1.00 per million tokens per hour. The output rate explicitly includes thinking tokens.
Image placeholder: A publication-date rate-card comparison using the verified Standard prices and conditions above. The final artwork should distinguish normal input, cache reads, cache writes or storage, and output without implying that token price equals completed-task cost.
Why Native Usage Metadata Matters
A cross-provider calculator cannot apply one generic “input plus output” formula to every response schema.
OpenAI
OpenAI reports total generated tokens in usage.output_tokens and exposes reasoning as the nested detail usage.output_tokens_details.reasoning_tokens. Reasoning tokens are already included in output_tokens, occupy the output allowance, and are billed at the output rate. Adding the nested reasoning value to output_tokens would double count it. OpenAI’s max_output_tokens limit covers visible output, reasoning, and other generated tokens; a response can end as incomplete before producing visible text. OpenAI’s reasoning guide documents the inclusive total and incomplete-response behavior.
Anthropic
Current Anthropic responses likewise expose an inclusive usage.output_tokens total and a read-only breakdown at usage.output_tokens_details.thinking_tokens. The latter must not be added to the parent output total. Anthropic also states that display: "summarized" and display: "omitted" have the same thinking-token cost: the visible summary is not the raw reasoning and is not a billing proxy. Anthropic’s thinking-cost documentation identifies output_tokens as the authoritative billing total.
For Gemini generateContent, usage_metadata reports prompt_token_count, cached_content_token_count, candidates_token_count, thoughts_token_count, and total_token_count. Google states that response pricing is the sum of candidate output and thinking tokens. total_token_count includes input as well, so it is a consistency check—not another billable output category. Google’s token-counting guide documents the fields and billing treatment.
A provider-aware ledger should therefore calculate:
OpenAI or Anthropic:
uncached input
+ cache reads
+ cache writes
+ inclusive output total
+ separately priced tools or service modifiers
Google generateContent:
uncached input
+ cached-content usage
+ cache storage duration
+ candidate output
+ thought tokens
+ separately priced tools or service modifiers
Effort Labels Are Not Comparable Units
OpenAI’s reasoning.effort, Anthropic’s output_config.effort, and Google’s thinkingLevel express relative behavior inside each provider’s system. They do not promise equal token budgets, latency, compute, or capability across vendors.
OpenAI describes effort as adaptive, with supported values varying by model. Anthropic calls effort a behavioral signal rather than a strict budget and says it affects text, tool calls, function arguments, and thinking. Google exposes only low, medium, and high for Gemini 3.8 Flash. A fair report should therefore compare observed usage and acceptance rates at named native settings, not imply that “max” and “high” are equivalent. OpenAI reasoning, Anthropic effort, and Gemini 3.8 Flash establish these provider-specific controls.
Proposed Validation: Fixed Six-Digit Semiprime Test
Status: proposed methodology; no requests, timing measurements, acceptance results, or billing reconciliation have been completed.
The original prompt allowed each model to choose its own semiprime. That is easy to verify but weak for comparison because models can select different problem difficulty. A stronger design supplies the same pre-generated test cases to every condition.
Before execution, generate a fixed list of 30 six-digit semiprimes from documented prime pairs using a deterministic seed. Store the list and its factors in a sealed evaluator file. The model sees only the composite number.
Return exactly one JSON object with these keys:
number, prime_a, prime_b, verification, explanation.
Factor the supplied six-digit integer number.
prime_a and prime_b must both be prime integers and
prime_a × prime_b must equal number.
verification must be the literal multiplication equation.
explanation must contain no more than 60 words.
Do not use external tools.
Run each case once under every model-effort condition. With eight retained models × two effort settings × 30 cases, the protocol contains 16 conditions and 480 primary requests. Astra access must be confirmed before randomization; unavailable conditions must be removed and the request count recomputed rather than silently replaced.
The workflow below combines provider-native usage capture with independent validation and aggregate billing reconciliation, following the accounting constraints in the official OpenAI, Anthropic, and Google usage documentation.
Experimental Controls
- Use first-party, synchronous Standard APIs in one recorded geography.
- Disable tools, browsing, fallbacks, batch processing, and premium speed tiers.
- Pin a model snapshot where the provider exposes one; otherwise record the requested and returned model identifiers.
- Explicitly set every reasoning or thinking value.
- Store UTC timestamps, endpoint, SDK version, request ID, raw response, complete usage object, finish status, retry count, and total latency.
- Use structured-output controls where supported, but apply the same independent validator to every provider.
- Preserve refusals, HTTP failures, malformed JSON, truncations, and retries as outcomes.
- Do not manufacture cache hits by padding or repeating prompts. Price cache activity only when reported.
Acceptance Rules
An accepted response must:
- Parse as exactly one JSON object with the required keys.
- Preserve the supplied six-digit number.
- Contain two integer factors.
- Pass deterministic primality checks by trial division through each factor’s integer square root.
- Satisfy
prime_a × prime_b = number. - Match the literal verification equation.
- Keep the explanation within 60 words and free of contradictions.
Report success as accepted results divided by all primary requests. Report latency, token counts, and cost using medians and interquartile ranges; add confidence intervals only after the raw sample exists. Retries should appear both as separate billed attempts and in the aggregate cost numerator.
Image placeholder: A reconciliation ledger with requested and returned model IDs, effort, input and cache categories, inclusive output, reasoning or thinking detail, finish status, validity, latency, calculated list-price cost, billed cost, and variance. Every result field remains “unmeasured” until supported by raw responses and billing evidence.
Reconcile the Ledger to the Bill
Per-request estimates are useful for debugging, but invoice reconciliation should use aggregate, unrounded token totals. Rounding hundreds of tiny request estimates before summing can manufacture a discrepancy.
Compare the reconstructed total with the provider’s billing export or console for the same project, API key, geography, service tier, and UTC interval. Anthropic’s Console can export usage and cost data by model and API key, while OpenAI and Google maintain API billing separately from their consumer subscriptions. Anthropic Console reporting, OpenAI billing, and Google API billing describe those billing surfaces.
Consumer plans are not interchangeable with API rate cards. OpenAI states that ChatGPT and API billing are separate; Anthropic says paid Claude plans do not include Console API usage; and Google limits Google AI plan benefits to the AI Studio interface while direct API use is billed separately. OpenAI, Anthropic, and Google document these distinctions.
Application Responsibilities the Rate Card Cannot Replace
Providers execute models and return usage metadata. The application still owns:
- Model and effort selection
- Output-contract definition
- Independent validation
- Retry and fallback policy
- Tool permission boundaries
- Per-request and aggregate spend ceilings
- Model-version and geography records
- Failure preservation
- Billing reconciliation
- The final acceptance decision
A low-rate model can lose if it produces more invalid JSON, wrong factors, truncations, or retries. A high-rate model can lose if additional reasoning does not improve acceptance enough to offset its higher output cost. Human review should also be included when it is a real production cost, although the semiprime microbenchmark deliberately excludes that dimension.
Tech Trend Insight Editorial Verdict
Start with the lowest-priced model-and-effort condition that clears predetermined correctness and latency thresholds on representative production tasks—not merely on this semiprime test.
Escalate only when a more expensive condition reduces failures, retries, truncation, or human rework enough to lower cost per accepted result.
Teams that cannot preserve raw usage, returned model identity, failures, and billing exports should not publish cross-provider cost rankings. A token-rate table alone is procurement input, not a completed-task benchmark.
What This Benchmark Cannot Establish
The proposed test can validate accounting instrumentation and a narrow class of deterministic outputs. It cannot rank general coding ability, factual accuracy, long-context retrieval, agent reliability, tool security, interactive usability, or human-review burden.
Its practical value is narrower: it tests whether an engineering team can identify the model actually used, capture every billable category once, reject incorrect output mechanically, preserve paid failures, and explain any difference between its calculated ledger and the provider’s bill.
FAQ
Are hidden reasoning and thinking tokens billed even when the application cannot see them?
Yes. OpenAI includes reasoning inside billed output tokens, Anthropic bills full thinking even when display is omitted, and Google’s output pricing includes thought tokens. Use provider-native usage fields rather than estimating from visible text.
Why can a lower-priced model cost more per accepted answer?
Because the numerator includes every billed attempt. Invalid JSON, incorrect results, truncations, retries, cache writes, and optional tools can outweigh a lower per-token rate.
Can ChatGPT, Claude, or Google AI subscription prices be compared directly with API token prices?
No. Each provider documents separate billing surfaces for consumer or workspace products and direct API usage. An API benchmark should use the tested project’s dated API rate card and billing records.
Official Sources
- OpenAI API Pricing
- OpenAI Reasoning Models Guide
- GPT-5.6 Sol Model Reference
- GPT-5.6 Terra Model Reference
- GPT-5.6 Luna Model Reference
- GPT-6 Astra Model Reference
- Anthropic Model Pricing
- Anthropic Thinking Cost and Steering
- Anthropic Effort Documentation
- Claude Fable 5.1 Model Reference
- Claude Fable 5 Model Reference
- Claude Opus 4.8 Model Reference
- Gemini Models
- Gemini Developer API Pricing
- Gemini Token Counting
