# Claude API pricing and token counts: a reference (November 2026)

> Claude 5.5 API list prices, cache and batch multipliers, minimum cacheable sizes, and a measured tokenizer comparison with the 4.x models.

- Author: Elber Dalfidan (https://dalfidan.dev/about/)
- Published: 2026-11-17
- Tags: ai, llm, cost, tokens
- Canonical URL: https://dalfidan.dev/writing/claude-token-pricing-reference/
- Language: en

![Watercolor illustration of an open ledger book, a stack of small tokens and a brass balance scale on a wooden desk in warm light.](https://dalfidan.dev/posts/claude-token-pricing-reference/cover.webp)

This page collects the Claude API prices, multipliers and token measurements behind [the practical checklist](https://dalfidan.dev/writing/reduce-llm-api-cost/). All prices are Anthropic list prices in USD per million tokens (MTok), read on 2026-11-17, unless marked as OpenAI.

## Model prices

| Model | Input | 5-min cache write | 1-hour cache write | Cache hit | Output | Batch input / output |
|---|---|---|---|---|---|---|
| Claude Opus 5.5 | $4 | $5 | $8 | $0.20 | $20 | $2 / $10 |
| Claude Sonnet 5.5 | $2 | $2.50 | $4 | $0.10 | $10 | $1 / $5 |
| Claude Haiku 5.5 (prompts up to 100k tokens) | $0.10 | $0.125 | $0.20 | $0.01 | $0.50 | $0.05 / $0.25 |
| Claude Haiku 5.5 (prompts over 100k tokens) | $0.50 | $0.625 | $1 | $0.05 | $2.50 | $0.25 / $1.25 |

Output costs 5 times as much as input for each model above. For comparison, Claude Opus 4.6 lists at $5 input and $25 output.

Modifiers that change the bill:

| Modifier | Effect |
|---|---|
| Haiku 5.5 over 100,000 tokens | The whole request pays the higher rates, cache reads included. Prompt length counts all input tokens, including cache reads and writes. |
| US-only inference (`inference_geo: "us"`) | 1.1x on all token categories for Claude 4.6 and later models |
| Fast mode on Opus 5.5 | $8 input, $40 output (double the standard rate); not available with the Batch API |

## Prompt caching multipliers

| Cache operation | Multiplier | Duration |
|---|---|---|
| 5-minute cache write | 1.25x base input price | 5 minutes |
| 1-hour cache write | 2x base input price | 1 hour |
| Cache read (hit) | 0.1x base input price on most models | Same as the preceding write |
| Cache read on Opus 5.5 and Sonnet 5.5 | 0.05x base input price | Same as the preceding write |

Per Anthropic, caching pays off after one cache read with the 5-minute write, and after two reads with the 1-hour write. The multipliers stack with the Batch API discount and data residency pricing.

## Minimum cacheable prompt length

| Minimum | Models |
|---|---|
| 512 tokens | Opus 5.5, Sonnet 5.5, Haiku 5.5 |
| 1,024 tokens | Sonnet 4.6 |
| 2,048 tokens | Opus 4.7 |
| 4,096 tokens | Opus 4.6, Opus 4.5, Haiku 4.5 |

Shorter prompts are processed without caching and no error is returned. If both `cache_creation_input_tokens` and `cache_read_input_tokens` are 0, nothing was cached.

Static tool overhead is a common caching target. Anthropic's pricing page says the browser use toolset adds about 6,600 input tokens per request, and the computer use toolset about 4,500.

## Batch API facts

| Item | Value |
|---|---|
| Price | "50 percent of the standard API prices," input and output |
| Typical completion | Most batches finish within 1 hour |
| Expiry | A batch that has not completed within 24 hours expires |
| Caching inside batches | Discounts stack; cache hits are best effort, with typical hit rates of 30 to 98 percent |
| Suggested cache | 1-hour cache for shared context, since batches can run longer than 5 minutes |
| Fast mode | Not available with batch |

## Tokenizer measurement: Claude 4.x versus 5.5

Anthropic states that Claude 4.7 and later models use a newer tokenizer that "produces approximately 30% more tokens for the same text," with the exact increase depending on content.

Method: on 2026-11-17, four texts were sent to Anthropic's `messages/count_tokens` endpoint for six models: claude-opus-4-6, claude-sonnet-4-6, claude-haiku-4-5-20251001, claude-opus-5-5, claude-sonnet-5-5 and claude-haiku-5-5. The three 4.x models returned identical counts, and so did the three 5.5 models.

| Sample text | Characters | Claude 4.6 / Haiku 4.5 | Claude 5.5 models | Increase |
|---|---|---|---|---|
| English prose (one paragraph, repeated 3 times) | 1,752 | 344 | 503 | +46% |
| Python code | 3,432 | 1,458 | 1,603 | +10% |
| JSON payload | 3,568 | 1,547 | 1,851 | +20% |
| Turkish prose (one paragraph, repeated 3 times) | 1,629 | 710 | 851 | +20% |

Caveats: each count is one run and includes a small fixed message overhead. The samples are short and synthetic, so this is a spot check, not a benchmark. Only input tokens can be counted this way; output tokens are not covered.

Effect on input price, Opus 5.5 ($4) versus Opus 4.6 ($5), for the same text:

| Sample | Opus 5.5 cost per $5 of Opus 4.6 spend |
|---|---|
| Python code (+10%) | about $4.40 |
| JSON payload, Turkish prose (+20%) | about $4.79 |
| English prose (+46%) | about $5.85 |

## Worked example: caching a static prefix

Hypothetical workload: a 20,000-token static prefix sent with 1,000 requests to Sonnet 5.5, each within 5 minutes of the previous one.

| Line | Calculation | Cost |
|---|---|---|
| Uncached | 20M tokens x $2/MTok | $40.00 |
| Cache write (once) | 20,000 x $2.50/MTok | $0.05 |
| Cache reads (999) | 19.98M x $0.10/MTok | $2.00 |
| Cached total | write + reads | about $2.05 |

The cached prefix costs about 95 percent less. The variable part of each prompt and all output tokens are unchanged.

## Worked example: output share of cost

Hypothetical Sonnet 5.5 call with 3,000 input tokens and 800 output tokens.

| Part | Tokens | Share of tokens | Cost | Share of cost |
|---|---|---|---|---|
| Input | 3,000 | 79% | $0.006 | 43% |
| Output | 800 | 21% | $0.008 | 57% |
| Total | 3,800 | 100% | $0.014 | 100% |

Cutting output to 400 tokens saves about 29 percent of the request. Cutting input by 1,000 tokens saves about 14 percent.

## When caching saves nothing

- **Prefix used once:** you pay 1.25x (or 2x) and get no read.
- **Prefix below the minimum:** silently not cached (see the table above).
- **Early content changes:** the cache matches an exact prefix in the order tools, system, messages. A timestamp or user ID near the top forces a new write every request.
- **Sparse traffic:** the 5-minute lifetime refreshes on each hit; a longer gap means a new write.
- **Mid-stream edits:** changing one level (tools, system, messages) invalidates that level and everything after it. Changing tool definitions invalidates the whole cache.

## OpenAI, for comparison

OpenAI's pricing page lists gpt-6.1-sol at $2 input and $10 output per million tokens, also a 5x ratio. On GPT-5.6 and later, OpenAI cache reads cost 0.1x uncached input (0.05x on GPT-6.1 Sol and Terra), and writes cost 1.25x for the 30-minute cache or 2.5x for the 12-hour cache. The minimum cacheable prefix is 1,024 tokens, and earlier OpenAI models have no cache-write charge. OpenAI's Batch API also gives a 50 percent discount, with a 24-hour completion window.

Last verified: 2026-11-17 (prices and documentation), token counts measured 2026-11-17. Prices, discounts and model names change; check the linked pages before you rely on a number.

## Sources

- Pricing, Anthropic (Claude Platform Docs), accessed 2026-11-17. https://platform.claude.com/docs/en/about-claude/pricing
- Prompt caching, Anthropic (Claude Platform Docs), accessed 2026-11-17. https://platform.claude.com/docs/en/build-with-claude/prompt-caching
- Message Batches API, Anthropic (Claude Platform Docs), accessed 2026-11-17. https://platform.claude.com/docs/en/build-with-claude/batch-processing
- Token counting, Anthropic (Claude Platform Docs), accessed 2026-11-17. https://platform.claude.com/docs/en/build-with-claude/token-counting
- Pricing, OpenAI (API docs, comparison provider), accessed 2026-11-17. https://developers.openai.com/api/docs/pricing
- Prompt caching, OpenAI (API docs, comparison provider), accessed 2026-11-17. https://developers.openai.com/api/docs/guides/prompt-caching
- Batch API, OpenAI (API docs, comparison provider), accessed 2026-11-17. https://developers.openai.com/api/docs/guides/batch
