Claude API pricing runs from $0.10 / $0.50 per million input / output tokens for Claude Haiku 5.5 to $8 / $40 for Claude Fable 5.2, with Claude Sonnet 5.5 at $2 / $10 and Claude Opus 5.5 at $4 / $20. Cache hits cost 2.5% to 10% of the input price, the Batch API halves every rate, and Haiku 5.5 is the only model whose rate rises with prompt length.
On a real bill, cache writes, Haiku 5.5's 100,000-token threshold, thinking tokens and search fees matter as much as the list price. All figures are Anthropic's list prices in US dollars from its pricing page, checked on 5 November 2026, and a month is 30 days.
Claude API pricing for every model
Prices per 1M tokens. "Cache read" is what Anthropic calls cache hits and refreshes.
| Model | Input | Output | 5-minute cache write | 1-hour cache write | Cache read | Batch input / output |
|---|---|---|---|---|---|---|
| Claude Fable 5.2, Mythos 5.2 (limited access) | $8.00 | $40.00 | $10.00 | $16.00 | $0.20 | $4.00 / $20.00 |
| Claude Fable 5.1, Mythos 5.1 (limited access) | $10.00 | $50.00 | $12.50 | $20.00 | $0.25 | $5.00 / $25.00 |
| Claude Fable 5, Mythos 5 (limited access) | $10.00 | $50.00 | $12.50 | $20.00 | $1.00 | $5.00 / $25.00 |
| Claude Opus 5.5 | $4.00 | $20.00 | $5.00 | $8.00 | $0.20 | $2.00 / $10.00 |
| Claude Opus 5, 4.8, 4.7, 4.6 and 4.5 | $5.00 | $25.00 | $6.25 | $10.00 | $0.50 | $2.50 / $12.50 |
| Claude Sonnet 5.5 | $2.00 | $10.00 | $2.50 | $4.00 | $0.10 | $1.00 / $5.00 |
| Claude Sonnet 5 | $2.00 | $10.00 | $2.50 | $4.00 | $0.20 | $1.00 / $5.00 |
| Claude Sonnet 4.6, Sonnet 4.5 | $3.00 | $15.00 | $3.75 | $6.00 | $0.30 | $1.50 / $7.50 |
| Claude Haiku 5.5, prompts up to 100,000 tokens | $0.10 | $0.50 | $0.125 | $0.20 | $0.01 | $0.05 / $0.25 |
| Claude Haiku 5.5, prompts over 100,000 tokens | $0.50 | $2.50 | $0.625 | $1.00 | $0.05 | $0.25 / $1.25 |
| Claude Haiku 4.5 | $1.00 | $5.00 | $1.25 | $2.00 | $0.10 | $0.50 / $2.50 |
- Fable 5.2 launched on 9 November 2026 at a fifth below Fable 5.1 and replaced it as Anthropic's top model; Fable 5.1 is still sold at $10 / $50 (release notes).
- Opus 5.5 launched on 22 September 2026 at a fifth below Opus 5. Sonnet 5.5's cache read fell from $0.20 to $0.10 on 7 October, when Haiku 5.5 launched (release notes).
- Sonnet 5's introductory $2 / $10 became its standard price; the rise to $3 / $15 planned for 1 September 2026 was cancelled.
- Mythos models are limited to verified organizations. Sonnet 4.5 retires on 30 November 2026.
- Claude 4.7 and later models use a tokenizer that produces about 30% more tokens for the same text than Sonnet 4.6 and earlier. Per word, Sonnet 5.5 input costs about 10% less than Sonnet 4.6, not the 33% the per-token prices suggest.
Current IDs: claude-fable-5-2, claude-opus-5-5, claude-sonnet-5-5 and claude-haiku-5-5, each with a 1M-token context window (models overview).
Claude cost per token and per 1,000 tokens
A token is a piece of text, usually part of a word. On Claude 4.7 and later models, 1M tokens is roughly 555,000 English words, so 1,000 words is about 1,800 tokens. Older models (Sonnet 4.6, Opus 4.6, Opus 4.5, Haiku 4.5) need about 1,330.
| Model | Input per token | Output per token | Input per 1,000 tokens | Output per 1,000 tokens | A 1,000-word reply |
|---|---|---|---|---|---|
| Fable 5.2 | $0.000008 | $0.00004 | $0.008 | $0.04 | $0.072 |
| Fable 5.1 | $0.00001 | $0.00005 | $0.01 | $0.05 | $0.090 |
| Opus 5.5 | $0.000004 | $0.00002 | $0.004 | $0.02 | $0.036 |
| Opus 5, 4.8, 4.7 | $0.000005 | $0.000025 | $0.005 | $0.025 | $0.045 |
| Opus 4.6, 4.5 | $0.000005 | $0.000025 | $0.005 | $0.025 | $0.033 |
| Sonnet 5.5, Sonnet 5 | $0.000002 | $0.00001 | $0.002 | $0.01 | $0.018 |
| Sonnet 4.6 | $0.000003 | $0.000015 | $0.003 | $0.015 | $0.020 |
| Haiku 5.5, up to 100,000 tokens | $0.0000001 | $0.0000005 | $0.0001 | $0.0005 | $0.0009 |
| Haiku 5.5, over 100,000 tokens | $0.0000005 | $0.0000025 | $0.0005 | $0.0025 | $0.0045 |
| Haiku 4.5 | $0.000001 | $0.000005 | $0.001 | $0.005 | $0.0067 |
- Thinking is billed as output, even when the thinking text isn't returned (thinking docs): 3,000 thinking tokens plus 500 visible ones bill as 3,500. The effort parameter controls it, defaulting to
mediumon Opus 5.5 and Haiku 5.5 andhighon Sonnet 5.5 and Fable 5.2. - Images cost ⌈width ÷ 28⌉ × ⌈height ÷ 28⌉ tokens, capped at 4,784 tokens on Claude 4.7 and later (vision docs). A 1000×1000 image is 1,296 tokens: $5.18 per 1,000 images on Opus 5.5, $2.59 on Sonnet 5.5 and $0.13 on Haiku 5.5.
- Counting tokens is free and exact for the model you name.
How prompt caching changes Claude token pricing
Prompt caching stores the start of a prompt (tools, system, then messages) for reuse, priced in the caching docs as multiples of the input price:
- A 5-minute cache write costs 1.25x; a 1-hour write costs 2x.
- A cache read costs 0.1x on most models, 0.05x on Opus 5.5 and Sonnet 5.5, and 0.025x on Fable 5.2, Fable 5.1 and the Mythos models of the same versions.
- A 5-minute write pays for itself on the first read. A 1-hour write needs two.
- The minimum cacheable prefix is 512 tokens on Opus 5.5, Sonnet 5.5, Haiku 5.5, Opus 5 and Fable, and 1,024 to 4,096 on older models (4,096 on Haiku 4.5). A shorter prefix is silently left uncached.
- The 5-minute lifetime counts from the start of the request, and each hit restarts it at no charge.

A change invalidates its level and everything after it. Editing a tool definition clears the whole cache; toggling web search or fast mode clears system and messages; changing effort or adding an image clears at least the messages.
Expiry is where caching gets expensive. A session idle past its cache lifetime rewrites its whole context on the next request: for 800,000 tokens on Opus 5.5, $4.00 instead of $0.16 as a read. Cache reads also don't count toward input-tokens-per-minute rate limits on current models.
Batch API: half price for work that can wait
The Message Batches API charges 50% of the standard input and output price on every model, and the caching multipliers stack on top, so a Sonnet 5.5 cache read in a batch costs $0.05 per 1M.
- One batch holds up to 100,000 requests or 256 MB. Most finish in under an hour; requests not run 24 hours after creation expire unbilled. Results stay downloadable for 29 days.
- Fast mode can't be batched, and Claude Managed Agents sessions have no batch mode.
- Cache hits in a batch are best effort (Anthropic reports 30% to 98%), so use the 1-hour cache for shared context.
Long context: one rate up to 1M tokens, except Haiku 5.5
On Claude 4.6 and later models, apart from Haiku 5.5, a 900,000-token request is billed at the same per-token rate as a 9,000-token one (long context pricing). GPT-6 models, by contrast, bill the whole request at 2x input and 1.5x output above 272,000 tokens.
Haiku 5.5 is priced by prompt length. A request with more than 100,000 prompt tokens pays five times the rate on everything: input, output, cache writes and cache reads. Cache reads and writes count toward the 100,000, and the whole request moves up, not just the part above the line.
| Prompt size (1,000 output tokens, no caching) | Haiku 5.5 | GPT-6 Luna | Sonnet 5.5 |
|---|---|---|---|
| 99,000 tokens | $0.0104 | $0.0104 | $0.21 |
| 101,000 tokens | $0.0530 | $0.0106 | $0.21 |
| 200,000 tokens | $0.1025 | $0.0205 | $0.41 |
| 300,000 tokens | $0.1525 | $0.0608 | $0.61 |

Going from 99,000 to 101,000 tokens multiplies the request's cost by 5.1, though even above the line Haiku 5.5 input costs a quarter of Sonnet 5.5's. Count tokens first, split long documents and trim history. Haiku 5.5 also keeps earlier turns' thinking blocks in context, so long chats grow faster than the tokenizer change alone explains (what's new in Haiku 5.5).
Tool use, web search and other Claude API costs
| Item | What it adds |
|---|---|
| Any tool in the request | 286 system-prompt tokens on Opus 5.5, Sonnet 5.5 and Haiku 5.5, plus your tool schemas |
| Bash tool | 325 input tokens on Claude 4.7 and later |
| Text editor tool | 974 input tokens on Claude 4.7 and later |
| Computer use toolset | About 4,500 input tokens, plus screenshots billed as image tokens |
| Browser use toolset | About 6,600 input tokens |
| Web search | $10 per 1,000 searches, plus results as input tokens; failed searches are free |
| Web fetch | Tokens only, about 2,500 for a 10 kB page |
| Code execution | Free with web search or fetch (2026-02-09 versions on); else 1,550 free hours a month per organization, then $0.05 per container-hour |
| Claude Managed Agents | Token rates plus $0.08 per running session-hour |
| Fast mode, Opus 5.5 | $8 / $40, twice the standard rate |
| Fast mode, Fable 5.2 | $16 / $80, twice the standard rate |
US-only inference (inference_geo: "us") | 1.1x every token price on Claude 4.6 and later |
Cap searches per request with max_uses on the web search tool. Fast mode buys up to 2.5x the output speed. Amazon Bedrock and Google Cloud (Google managed) set their own Claude prices, with regional endpoints 10% above global ones. Volume discounts are negotiated case by case with Anthropic's sales team.
Three worked monthly bills
Output includes thinking, and each line maps to a field in the API's usage block.

Bill 1: a support chatbot on Haiku 5.5, $159 a month
- 10,000 customer messages a day: 300,000 requests a month.
- 10,000 input tokens per request (instructions, tools, conversation so far): 80% cache reads, 20% 5-minute cache writes for the new turn.
- 400 output tokens at
loweffort, and every prompt far below 100,000 tokens.
| Line | Tokens a month | Price per 1M | Cost |
|---|---|---|---|
| Cache writes | 600M | $0.125 | $75.00 |
| Cache reads | 2,400M | $0.01 | $24.00 |
| Output | 120M | $0.50 | $60.00 |
| Total | $159.00 |
Without caching, the month costs $360.00. The same counts cost $2,940.00 on Sonnet 5.5. Haiku 4.5's older tokenizer would count the same text as about 23% fewer tokens, roughly $1,223 a month, so Haiku 5.5 still costs 87% less. GPT-6 Luna's identical list prices give $159.00 too.
Bill 2: a research agent with web search on Opus 5.5, $1,876 a month
- 2,000 reports a month, each with 15 model calls and 8 web searches: 30,000 calls and 16,000 searches.
- 40,000 input tokens per call (instructions, tools, search results so far): 90% cache reads, 10% 5-minute writes.
- 1,500 output tokens per call at the default
mediumeffort.
| Line | Volume a month | Price | Cost |
|---|---|---|---|
| Cache writes | 120M tokens | $5.00 per 1M | $600.00 |
| Cache reads | 1,080M tokens | $0.20 per 1M | $216.00 |
| Output | 45M tokens | $20.00 per 1M | $900.00 |
| Web search | 16,000 searches | $10 per 1,000 | $160.00 |
| Total | $1,876.00 |
That's $0.94 per report. Cache reads are 90% of the input tokens but 12% of the bill; the writes cost almost three times as much. At a 70% hit rate the month costs $3,028.00; with no caching, $5,860.00; in fast mode, $3,592.00. Sonnet 5.5 comes to $1,018.00 on the same counts, though its default high effort will likely add output.
Check the spend cap before launch: Anthropic stops usage at $500 a month on the Start tier and $1,000 on Build, returning a 429 enforced_spend_limit_reached until the 1st. On Build, this bill is cut off on about day 16.
Bill 3: contract review through Batch, from $2,600 to $66
- 10,000 contracts a month, 120,000 input tokens each (2,000 of them instructions), 2,000 output tokens, no caching.
| Setup | Price per 1M, input / output | Month |
|---|---|---|
| Sonnet 5.5, live | $2.00 / $10.00 | $2,600.00 |
| Sonnet 5.5, Batch | $1.00 / $5.00 | $1,300.00 |
| Opus 5.5, Batch | $2.00 / $10.00 | $2,600.00 |
| Haiku 5.5, Batch, whole contract (over 100,000) | $0.25 / $1.25 | $325.00 |
| Haiku 5.5, Batch, two halves of 61,000 tokens | $0.05 / $0.25 | $66.00 |
Each half carries the instructions and returns 1,000 tokens of findings. Splitting loses references between halves, so test quality on a sample first. Batch halves the bill; staying under Haiku 5.5's threshold cuts what's left by about 80%.
Check the math in Python
The function prices one request from the fields the API returns, and reproduces the three bills.
# Claude list prices, US$ per 1M tokens, checked 5 Nov 2026 (Fable 5.2 added 17 Nov):
# (input, output, 5-minute cache write, 1-hour cache write, cache read)
PRICES = {
"claude-fable-5-2": (8.00, 40.00, 10.00, 16.00, 0.20),
"claude-fable-5-1": (10.00, 50.00, 12.50, 20.00, 0.25),
"claude-opus-5-5": (4.00, 20.00, 5.00, 8.00, 0.20),
"claude-sonnet-5-5": (2.00, 10.00, 2.50, 4.00, 0.10),
"claude-haiku-5-5": (0.10, 0.50, 0.125, 0.20, 0.01), # prompts up to 100,000 tokens
"claude-haiku-5-5-long": (0.50, 2.50, 0.625, 1.00, 0.05), # prompts over 100,000 tokens
"claude-haiku-4-5": (1.00, 5.00, 1.25, 2.00, 0.10),
}
WEB_SEARCH = 10.00 / 1000 # per search
def request_cost(model, uncached=0, write_5m=0, write_1h=0, cache_read=0, output=0,
searches=0, batch=False, us_only=False):
"""US$ for one request. Output includes thinking tokens."""
prompt = uncached + write_5m + write_1h + cache_read
if model == "claude-haiku-5-5" and prompt > 100_000:
model = "claude-haiku-5-5-long" # the whole request moves to the higher rate
p_in, p_out, p_w5, p_w1, p_read = PRICES[model]
usd = (uncached * p_in + write_5m * p_w5 + write_1h * p_w1
+ cache_read * p_read + output * p_out) / 1e6
if batch:
usd *= 0.5
if us_only: # inference_geo="us"
usd *= 1.1
return usd + searches * WEB_SEARCH
bill_1 = 300_000 * request_cost("claude-haiku-5-5", write_5m=2_000, cache_read=8_000, output=400)
bill_2 = 30_000 * request_cost("claude-opus-5-5", write_5m=4_000, cache_read=36_000, output=1_500) \
+ 16_000 * WEB_SEARCH
bill_3_whole = 10_000 * request_cost("claude-haiku-5-5", uncached=120_000, output=2_000, batch=True)
bill_3_split = 20_000 * request_cost("claude-haiku-5-5", uncached=61_000, output=1_000, batch=True)
print(round(bill_1, 2), round(bill_2, 2), round(bill_3_whole, 2), round(bill_3_split, 2))
# 159.0 1876.0 325.0 66.0
To price real traffic, count the prompt first (free), then read the usage block. This uses the anthropic Python SDK 2.4.0:
import anthropic
client = anthropic.Anthropic() # reads ANTHROPIC_API_KEY
messages = [{"role": "user", "content": "Classify this ticket: ..."}]
size = client.messages.count_tokens(model="claude-haiku-5-5", messages=messages).input_tokens
if size > 100_000:
print(f"{size} tokens: this request is billed at Haiku 5.5's higher rate")
reply = client.messages.create(
model="claude-haiku-5-5",
max_tokens=2_000, # thinking plus the visible reply
output_config={"effort": "low"}, # Haiku 5.5 defaults to medium
cache_control={"type": "ephemeral"}, # automatic caching, 5-minute lifetime
messages=messages,
)
u = reply.usage
print(request_cost(
"claude-haiku-5-5",
uncached=u.input_tokens,
write_5m=u.cache_creation_input_tokens or 0,
cache_read=u.cache_read_input_tokens or 0,
output=u.output_tokens,
))
input_tokens counts only tokens after the last cache breakpoint; the full prompt is the sum of the three input fields. With 1-hour caching, pass u.cache_creation.ephemeral_1h_input_tokens as write_1h. For more workloads worked this way, see how much an LLM API costs per month.
Claude vs GPT-6 and Gemini prices
Per 1M tokens, from the OpenAI and Gemini API pricing pages on 5 November 2026.
| Model | Input / output | Cache read | Long prompts |
|---|---|---|---|
| GPT-6 Astra | $10 / $50 | $1.00 | 2x input, 1.5x output above 272,000 |
| Claude Fable 5.2 | $8 / $40 | $0.20 | Same rate to 1M |
| Claude Opus 5.5 | $4 / $20 | $0.20 | Same rate to 1M |
| Gemini 4 Argon | $2 / $10, then $4 / $20 from 1 Dec 2026 | $0.10, then $0.20 | One rate listed |
| Claude Sonnet 5.5 | $2 / $10 | $0.10 | Same rate to 1M |
| GPT-6.1 Sol | $2 / $10 | $0.10 | 2x input, 1.5x output above 272,000 |
| Gemini 3.8 Flash | $0.75 / $3.75, then $1.50 / $7.50 from 1 Jan 2027 | $0.075, then $0.15 | One rate listed |
| Claude Haiku 5.5 | $0.10 / $0.50 | $0.01 | $0.50 / $2.50 above 100,000 |
| GPT-6 Luna | $0.10 / $0.50 | $0.01 | $0.20 / $0.75 above 272,000 |
Sonnet 5.5 and GPT-6.1 Sol match down to the cache read, and both charge $10 per 1,000 web searches. Haiku 5.5 and GPT-6 Luna match below 100,000 tokens; above it Luna costs less, so Bill 3 sent whole through Luna's Batch is $65.00 against $325.00. Fable 5.2 costs a fifth less than GPT-6 Astra per token, and its cache read is a fifth of Astra's. Google's Search grounding costs $14 per 1,000 after 5,000 free a month. Tokenizers differ, so compare on your own prompts, or by cost per finished task as in Claude alternatives for coding.
Retired and retiring Claude models
From Anthropic's model deprecations page. Requests to a retired model fail.
| Model ID | Status | Date | Replacement | Price per 1M, old to new |
|---|---|---|---|---|
claude-sonnet-4-5-20250929 | Deprecated | Retires 30 Nov 2026 | claude-sonnet-5-5 | $3 / $15 to $2 / $10 |
Fast mode on claude-opus-4-8 | Deprecated | Removed 30 Nov 2026 | Fast mode on claude-opus-5-5 | $10 / $50 to $8 / $40 |
claude-mythos-preview | Deprecated | Deprecated 9 Jun 2026, retirement to be announced | Not named | |
claude-opus-4-1-20250805 | Retired | 5 Aug 2026 | claude-opus-4-8 | $15 / $75 to $5 / $25 |
claude-opus-4-20250514 | Retired | 15 Jun 2026 | claude-opus-4-8 | $15 / $75 to $5 / $25 |
claude-sonnet-4-20250514 | Retired | 15 Jun 2026 | claude-sonnet-5-5 | $3 / $15 to $2 / $10 |
claude-3-haiku-20240307 | Retired | 20 Apr 2026 | claude-haiku-4-5-20251001 | |
claude-3-5-haiku-20241022 | Retired | 19 Feb 2026 | claude-haiku-4-5-20251001 | $0.80 / $4 to $1 / $5 |
claude-3-7-sonnet-20250219 | Retired | 19 Feb 2026 | claude-sonnet-5-5 |
Where both prices are listed, every move lowers the price except Haiku 3.5 to Haiku 4.5. Haiku 4.5 (not sooner than 15 October 2026) and Opus 4.5 (not sooner than 24 November 2026) are still active with no retirement date, and Anthropic's 60 days' notice means neither can retire before January 2027. Haiku 4.5 to Haiku 5.5 cuts the per-token price by 90%, but temperature, budget_tokens and assistant prefill can each return a 400 on 5.5. Some retired models remain on Bedrock or Google Cloud at those providers' prices.
What developers report
- "Haiku and Luna now have the exact same price up to 100,000 tokens." (Hacker News commenter, 7 Oct 2026, link)
- "Destroyed by Anthropics crazy decision to price it x5 after 100k context." (Hacker News commenter on Haiku 5.5, 26 Oct 2026, link)
- "Anthropic's recent tokenizer change generates 30% more tokens for exact same input" (Hacker News commenter, 9 Jul 2026, link)
- A Claude Code user reported idle-session warnings that "your next message will re-cache about 800k tokens" (GitHub issue #95222, 17 Sep 2026, link)
- An independent study of agent sessions on OpenAI, Anthropic and Google found that prompt caching "reduces API costs by 41-80%" (arXiv 2601.06007, revised 31 Jan 2026, link)
Paying for Claude through Aight
Aight lists Claude Opus 5.5, Sonnet 5.5, Haiku 5.5 and Fable 5.1 at Anthropic's list prices, cache rates included, behind one OpenAI-compatible key. A $100 recharge costs $103 with the 3% processing fee and adds $110 of balance with the 10% extra, so Sonnet 5.5 works out to about $1.87 / $9.36 per 1M tokens and Opus 5.5 to $3.75 / $18.73.
None of the three bills above is a good fit, and direct costs less for each:
- Fable 5.2 isn't on Aight's models page yet; Fable 5.1 is, at $10 / $50.
- Aight's API reference documents chat completions, embeddings and the model list, so there's no Batch discount and no Anthropic web search tool.
- It documents
model,messagesandstreamas the request fields, so test whether your prompts get cache hits before counting on cached prices. - Claude Code speaks Anthropic's Messages API, so it doesn't run on Aight directly. For heavy daily Claude Code use, compare a Max plan in the Claude Code pricing guide.
Aight fits live Sonnet, Opus or Fable traffic running next to GPT or Gemini models: one prepaid balance, a monthly cap and allowed-model list per key, and unspent paid balance refundable. The Claude API key guide covers setting up the direct route.
FAQ
Is the Claude API free?
No. New Console accounts get a small amount of free usage for testing; after that, usage is prepaid at list prices (see buying Claude API usage and fixing a failed payment). Token counting is free.
How much does the Claude API cost per month?
The Claude API cost per month is tokens times price for each line (uncached input, cache writes, cache reads, output) plus searches. The bills above run from $66 to $2,600 depending on model, caching and Batch. Price a day of real traffic from the usage fields and multiply by 30.
Is Claude AI API pricing included in a Claude Pro or Max plan?
Not on Pro. Claude AI API pricing is separate from claude.ai plans, but since 7 October 2026 Max ($100 a month) includes $100 of API usage a month, Ultra ($200) $200, and Team plans $20 per Standard seat and $100 per Premium seat, pooled up to $500 (Anthropic). It expires each billing cycle and doesn't cover Claude Code.
Is Claude Code billed at Claude API prices?
With a Console API key, yes: Anthropic's Claude Code cost docs say it charges by API token consumption, averaging about $13 per developer per active day and $150 to $250 per developer a month across enterprise deployments. On Pro, Max or Ultra, usage counts against the plan's limits instead.
Why is the bill higher than the token estimate?
Usually thinking tokens, which bill as output even when hidden, or the newer tokenizer's roughly 30% more tokens per word. Other causes: cache writes at 1.25x, expired caches rewritten, tool definitions resent on every call, web searches at $10 per 1,000, and Haiku 5.5 prompts that cross 100,000 tokens.
Sources
- Anthropic, Pricing, claude.com/pricing, Models overview, Model deprecations, Release notes
- Anthropic, Prompt caching, Batch processing, Rate limits and spend limits, Token counting
- Anthropic, Thinking, Effort, Vision, Fast mode, Web search tool
- Anthropic, What's new in Claude Haiku 5.5, What's new in Claude Opus 5.5, API allowance for Max, Ultra and Team plans, Claude Code costs
- PyPI, anthropic 2.4.0; GitHub, anthropics/claude-code issue #95222
- OpenAI, Pricing and model pages for GPT-6 Astra, GPT-6.1 Sol, GPT-6 Luna
- Google, Gemini API pricing
- Hacker News comments 49997716, 50251913, 48844999
- Lumer et al., Don't Break the Cache: An Evaluation of Prompt Caching for Long-Horizon Agentic Tasks, arXiv
- Hugging Face, Prompt Caching Explained: Stop Overpaying for AI Agents
- Aight, Models and pricing, API reference, Refund policy
Checked on 5 November 2026. Updated 17 November 2026: Claude Fable 5.2 prices, and Aight's current model list.