State of the API, August 2026: Blended Cost vs. P95 Latency

Price changes this month

Frontier-tier list prices now sit between $4 and $5 per million input tokens and $20 to $25 per million output tokens, a step down from the $25 to $30 output band this brief reported earlier. Mid tiers, the workhorse for most production traffic, cluster tightly at $2 input and $10 to $12 output.

Model	Input $/Mtok	Output $/Mtok	Note
Claude Fable 5 (Anthropic)	$10	$50	Premium reasoning tier
Claude Opus 5 (Anthropic)	$5	$25	Frontier tier
GPT-5.6 Sol (OpenAI)	$4	$20	Promotional rate, held at least through 21 Nov 2026
Gemini 3.1 Pro Preview (Google)	$2	$12	Prompts up to 200K tokens; $4 / $18 above that
GPT-5.6 Terra (OpenAI)	$2	$12	Confirmed on OpenAI's own page; earlier tracker disagreement resolved
Claude Sonnet 5 (Anthropic)	$2	$10	Introductory rate is now the standard rate; the 1 Sep increase was cancelled
Claude Haiku 4.5 (Anthropic)	$1	$5	High-volume tier
DeepSeek V4-Flash	$0.44	$1.32	Peak, cache miss; $0.22 / $0.66 off-peak
GPT-5.6 Luna (OpenAI)	$0.20	$1.20	Cheapest listed frontier-capable API

All figures were re-verified against each provider's official pricing page on 26 August 2026. The GPT-5.6 Terra rate that independent trackers disagreed on at first writing is confirmed at $2 input and $12 output on OpenAI's own page, a reminder to check the primary source rather than any single aggregator.

Two mechanics matter more than the headline number. Output tokens cost 4 to 8 times more than input on almost every provider, since generation is more compute-intensive than reading a prompt. And a Batch API discount (roughly 50 percent off both input and output) is available from Anthropic, OpenAI, and Google for workloads that can tolerate asynchronous processing.

Latency board

Speed leadership sits with the lightweight tiers, and the gap between headline and production latency is the thing most comparisons hide.

Gemini 2.5 Flash-Lite (non-reasoning) holds the lowest time-to-first-token on Artificial Analysis at 0.28 seconds, ahead of Command A+ at 0.39s and Gemini 2.5 Flash (non-reasoning) at 0.45s. Sub-400ms is the exception, not the norm: only two tracked models are under it. Specialized inference hardware leads raw output speed on the open models it hosts, and by a wider margin than most comparisons report: on gpt-oss-120b, Cerebras runs 1,650 tokens per second and Groq 474, against 343 on Azure. That lead is model-specific rather than universal, though. On Llama 3.3 70B, Groq tops the provider list at 330 tokens per second, and on Qwen3 235B neither Groq nor Cerebras appears among the tracked providers at all. Hyperscaler frontier APIs (OpenAI, Anthropic, Google) bundle latency with model quality, so they are rarely the fastest option on TTFT alone.

Anchor your SLA on tail latency rather than the median. That is our recommendation, not a published finding, and the distinction matters here: Artificial Analysis reports a 72-hour median (P50) for provider endpoints, not percentiles. The only P95 time-to-first-token it publishes sits in AA-AgentPerf, which benchmarks vendor-submitted hardware deployments under sustained concurrency rather than commercial APIs, and which publishes no matching median to compare it against. There is therefore no public P95-to-median ratio for provider APIs that you can borrow, including from this page. Measure your own tail, because it is the number your users feel and nobody publishes it for you.

Blended cost-to-intelligence

Comparing input price alone hides the real bill. Compute a blended rate using your actual input-to-output token ratio, then compare that to task quality.

def blended_cost_per_mtok(in_price: float, out_price: float, in_share: float = 0.8) -> float:
    """Weight input/output prices by YOUR real token mix, not a generic 50/50 split."""
    return in_price * in_share + out_price * (1 - in_share)

def end_to_end_seconds(ttft_s: float, output_tps: float, output_tokens: int = 500) -> float:
    """What the user actually waits for. Both inputs are published medians."""
    return ttft_s + output_tokens / output_tps

# An input-heavy RAG workload (80% input tokens), rates verified 26 Aug 2026:
print(f"{blended_cost_per_mtok(2.0, 10.0):.2f} $/Mtok  Claude Sonnet 5")
print(f"{blended_cost_per_mtok(2.0, 12.0):.2f} $/Mtok  GPT-5.6 Terra")
print(f"{blended_cost_per_mtok(5.0, 25.0):.2f} $/Mtok  Claude Opus 5")

# gpt-oss-120b on three providers, Artificial Analysis medians, 26 Aug 2026:
print(f"{end_to_end_seconds(1.65, 1650.1):.2f}s  Cerebras")
print(f"{end_to_end_seconds(0.98,  301.0):.2f}s  Nebius")
print(f"{end_to_end_seconds(4.95,  474.2):.2f}s  Groq")

Running this gives $3.60, $4.00, and $9.00 per million tokens. Sonnet 5 and Terra list the identical $2 input rate, yet Terra costs 11 percent more on this mix purely from its output rate, and the jump to Opus 5 is 2.5x rather than the 2.5x-on-input that the sticker prices suggest. Recompute it for your own input/output ratio before choosing a tier. The second block makes the same point about speed: for a 500-token answer, Nebius finishes in 2.64s against Groq's 6.00s on the same model, despite Groq generating 1.6 times faster, because time-to-first-token dominates at that length. Throughput only wins once the answer is long enough to pay back the wait.

What it means for your stack

If you are on Claude Sonnet 5, the September 1 increase this brief originally told you to budget for has been cancelled, and the introductory $2/$10 is now the standard rate. That reversal is the lesson worth keeping: a dated price commitment is a forecast, not a fact, and it is worth re-checking before it reaches a budget. If TTFT dominates your user experience (a chat interface), the Flash-Lite class of models is currently the strongest latency-to-price trade, but validate on your own region and concurrency, since public benchmarks understate real-world tail latency. If you are optimizing for raw throughput on an open model, specialized inference hardware still leads by a wide margin over general-purpose hyperscaler endpoints.

For the deeper architectural question behind any of this, cost per query also depends heavily on whether you are re-loading a full corpus per call or retrieving a bounded slice, covered in the guide to RAG vs. long-context.

Methodology

Pricing figures are compiled from each provider's official pricing documentation and were last re-verified against those pages on 26 August 2026. Latency figures are drawn from Artificial Analysis, which benchmarks standard workloads eight times a day from a single virtual machine in Google Cloud's us-central1-a zone and reports a 72-hour median. Because time-to-first-token includes network latency, that measurement location advantages providers near it, and every TTFT figure here should be read as a median from one vantage point rather than a number you will reproduce. Latency figures were re-verified against Artificial Analysis on 26 August 2026. Where independent trackers disagreed with each other, that disagreement is noted rather than resolved by picking one silently.

This brief is a snapshot, not a live feed. Numbers move between issues, and every figure carries a re-verify expectation before you rely on it for a purchasing decision.

What remains uncertain

Both open items from the first cut are now closed. The GPT-5.6 Terra rate is confirmed at $2 input and $12 output on OpenAI's page, and Gemini 3.1 Pro Preview's long-context tier is confirmed to trigger above 200K tokens per prompt, at $4 input and $18 output. Two new items are open instead: DeepSeek bills on a peak and off-peak split, so a workload's effective rate depends on when it runs, and GPT-5.6 Sol's $4/$20 is a promotional rate committed only through 21 November 2026. And no public benchmark reports tail latency for commercial provider APIs, so the P95 an SLA needs is a number you will have to measure yourself, under your own concurrency and regional routing.

Primary sources

1. Artificial Analysis, artificialanalysis.ai. Independent TTFT, tokens/sec, and P50/P95 latency measurement across provider endpoints.
2. Anthropic, Claude API pricing (official). Model pricing, including the Sonnet 5 introductory-rate end date.
3. OpenAI, API pricing (official). GPT model pricing.
4. Google, Gemini API pricing (official). Gemini model pricing.

This is a dated snapshot, not a live feed. All figures reflect the publish date above and must be re-verified against official sources before use in a purchasing decision.