Claude API Pricing (2026): API Key, Models, and Setup
The Claude API, also called the Anthropic API, gives developers direct access to Claude models through the Messages API. To start, create an API key in the Claude Console, call https://api.anthropic.com/v1/messages, include an Anthropic API version, and choose a current model ID.
This guide covers Claude API pricing, API key setup, model selection, prompt caching, batch discounts, long-context costs, and practical budget controls. Pricing was last verified against Anthropic's official documentation on October 12, 2026.
Claude API key, base URL, and first request
- Sign in at platform.claude.com and create a personal key for local development or a service-account key for shared production workloads.
- Store the key as
ANTHROPIC_API_KEY; do not expose it in browser code or commit it to a repository. - Send requests to
https://api.anthropic.com/v1/messages. - Include
anthropic-version: 2023-06-01. Anthropic now documentsAuthorization: Bearer <key>as the primary header; the legacyx-api-keyheader remains supported.
export ANTHROPIC_API_KEY="your-key"
curl https://api.anthropic.com/v1/messages \
-H "Authorization: Bearer $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-sonnet-5-5",
"max_tokens": 512,
"messages": [{"role": "user", "content": "Explain prompt caching in three bullets."}]
}'
The direct Claude API uses Anthropic's Messages format, not the OpenAI Chat Completions schema. If your application needs the same OpenAI SDK across Claude, GPT, Gemini, and other providers, use an OpenAI-compatible gateway and verify how it translates system messages, tool calls, streaming events, and usage fields.
Official references: Claude API overview, authentication, and current model pricing.
Claude API pricing in 2026: quick table
Anthropic prices Claude models per million tokens, usually written as MTok. Input tokens are the prompt and context you send. Output tokens are the generated response. Prompt caching adds separate write and read prices. The table below is based on Anthropic's official pricing page on October 11, 2026.
| Claude model | Intended use | Input | Output | 5-minute cache write | 1-hour cache write | Cache hit / refresh |
|---|---|---|---|---|---|---|
| Claude Fable 5.1 | Demanding reasoning and long-horizon agentic work | $10 / MTok | $50 / MTok | $12.50 / MTok | $20 / MTok | $0.25 / MTok |
| Claude Opus 5.5 | Long-running agentic coding and knowledge work | $4 / MTok | $20 / MTok | $5 / MTok | $8 / MTok | $0.20 / MTok |
| Claude Sonnet 5.5 | Balanced speed and intelligence | $2 / MTok | $10 / MTok | $2.50 / MTok | $4 / MTok | $0.10 / MTok |
| Claude Haiku 5.5, prompts up to 100k tokens | High-volume classification, extraction, and routing | $0.10 / MTok | $0.50 / MTok | $0.125 / MTok | $0.20 / MTok | $0.01 / MTok |
| Claude Haiku 5.5, prompts over 100k tokens | Long-prompt Haiku requests | $0.50 / MTok | $2.50 / MTok | $0.625 / MTok | $1 / MTok | $0.05 / MTok |
Sources: Anthropic pricing, Anthropic prompt caching, and Anthropic Message Batches documentation:
- https://platform.claude.com/docs/en/about-claude/pricing
- https://platform.claude.com/docs/en/build-with-claude/prompt-caching
- https://platform.claude.com/docs/en/build-with-claude/batch-processing
The cost formula procurement teams should actually approve
A simple Claude API pricing 2026 estimate should separate five lines instead of one blended average:
monthly_cost =
uncached_input_mtok * input_rate
+ output_mtok * output_rate
+ cache_write_mtok * cache_write_rate
+ cache_read_mtok * cache_read_rate
+ feature_or_residency_multipliers
+ gateway_or_platform_fees
That structure matters because most production surprises come from a line item that was hidden during evaluation:
- Output tokens can dominate summarization, code generation, and agent tasks. A model that looks affordable on input can become expensive if it writes long answers.
- Cache writes are more expensive than base input, but repeated reads are much cheaper.
- Batch processing can cut eligible asynchronous input and output token costs by 50%.
- Haiku 5.5 long-context requests have a higher price tier once the prompt is over 100,000 tokens.
- US-only inference can add a 1.1x multiplier for Claude 4.6 and later models, according to Anthropic's pricing notes.
- Retries and failures can double effective cost if the application repeats full prompts after timeout or overload errors.
For finance, the approved budget should be tied to accepted work, not just raw tokens. Track cost per accepted answer, accepted code patch, resolved support ticket, extracted document, or completed agent run.
Worked example: Sonnet 5.5 production workload
Suppose a product team expects a monthly Claude Sonnet 5.5 workload with:
- 100 million uncached input tokens.
- 40 million output tokens.
- No prompt caching.
- No batch processing.
At the current listed Sonnet 5.5 rates, the estimate is:
| Line item | Math | Cost |
|---|---|---|
| Input | 100 MTok * $2 | $200 |
| Output | 40 MTok * $10 | $400 |
| Total | $200 + $400 | $600 |
If the same traffic is fully eligible for Message Batches, Anthropic lists a 50% discount on both input and output tokens, so the token portion would estimate to $300. That is useful for offline evaluation, enrichment, report generation, and backfills. It does not help latency-sensitive chat or interactive agent turns where the user is waiting.
Prompt caching changes the Claude API cost curve
Prompt caching is the most important lever for repeated context. Anthropic's docs describe 5-minute and 1-hour cache durations, cache write charges when content is first stored, and cache read charges when a later request retrieves the cached prefix.
General pricing rules from Anthropic's prompt caching docs:
- 5-minute cache writes are 1.25x the base input token price.
- 1-hour cache writes are 2x the base input token price.
- Cache reads are usually 0.1x the base input token price.
- Claude Fable 5.1 and Claude Mythos 5.1 cache hits are listed at 2.5% of standard input price.
- Claude Opus 5.5 and Claude Sonnet 5.5 cache hits are listed at 5% of standard input price.
- Cache multipliers can stack with other modifiers, including batch processing and data residency.
For Sonnet 5.5, 80 MTok of reusable context costs $160 as normal input. A 5-minute cache write costs $200. A later cache hit on that same 80 MTok costs $8. Two uncached calls would cost $320 for that context; one write plus one read costs $208. That is why caching can pay back quickly when a system prompt, tool schema, codebase context, policy pack, or retrieved document bundle repeats.
When to use each Claude model for budget control
Use model selection as a routing policy, not a one-time preference.
| Workload | Default routing idea | Cost risk to watch |
|---|---|---|
| Classification, extraction, routing, lightweight transforms | Start with Claude Haiku 5.5 | Long prompts over 100k tokens move Haiku into its higher price tier. |
| Product chat, support drafts, structured analysis | Start with Claude Sonnet 5.5 | Output length and retry behavior can dominate total cost. |
| Coding agents, long reasoning, complex planning | Test Claude Opus 5.5 or Fable 5.1 against Sonnet | Higher output rates require strict acceptance metrics. |
| Offline enrichment, evaluations, backfills | Use Message Batches when latency is not required | Batch results are asynchronous and batches can expire if not completed within 24 hours. |
| Repeated policies, tool schemas, docs, code context | Use prompt caching | Cache hit rate depends on stable prefixes and request timing. |
The practical rule: start cheaper, route up only when quality or completion rate proves it. If Sonnet solves 97% of a workflow and Opus solves 98%, procurement should compare the incremental accepted-work cost, not the model's reputation.
The seven-day Claude API budget worksheet
Before approving a 2026 Claude API budget, run a seven-day workload test and capture the same fields for every request:
| Field | Why it matters |
|---|---|
route_name |
Separates support chat, coding agent, extraction, evals, and background jobs. |
model |
Shows where premium models are actually used. |
input_tokens |
Base prompt cost and context growth. |
output_tokens |
Often the largest hidden cost line. |
cache_creation_input_tokens |
Shows cache write volume. |
cache_read_input_tokens |
Shows whether caching is paying off. |
batch_eligible |
Flags jobs that should move to Message Batches. |
retry_count |
Converts reliability issues into cost evidence. |
accepted_result |
Lets teams calculate cost per useful outcome. |
customer_id or team_id |
Supports chargeback, showback, and abusive-use review. |
At the end of the week, group spend by route and calculate:
cost_per_accepted_result = total_route_cost / accepted_results
cache_hit_rate = cache_read_input_tokens / (cache_read_input_tokens + cache_creation_input_tokens + uncached_input_tokens)
retry_cost_share = retry_request_cost / total_route_cost
batchable_cost_share = batch_eligible_cost / total_route_cost
Those four metrics will usually tell you more than a generic Claude API pricing calculator.
Where Flatkey fits in the Claude API pricing workflow
Claude pricing becomes an operations problem when Claude is one route among many models, teams, agents, and environments. Flatkey gives developers one API key, one balance, one invoice, one SLA, and access to 100+ official models plus 1,000+ pay-per-call tools from one account. The live Flatkey site also states that failed Flatkey-side calls cost nothing and that existing OpenAI SDK code can work by replacing the base URL.
Use Flatkey when you need to:
- Compare Claude API cost against OpenAI, Gemini, DeepSeek, Qwen, and other routes without maintaining separate provider keys in every repo.
- Centralize AI API spend in one prepaid balance and invoice.
- Track successful requests with request IDs and usage records.
- Govern access with sub-keys, budgets, and model allowlists.
- Route workloads by cost, reliability, latency, and accepted-result rate rather than by vendor habit.
If your team only uses one Claude model from one service, direct Anthropic billing may be enough. If Claude is part of a broader AI product stack, a gateway and usage ledger make Claude API pricing 2026 easier to compare, control, and explain to finance.
Internal links for deeper cost planning
- For the canonical model-rate page, read Claude API pricing in 2026.
- For repeated prompt economics, read prompt caching workflow.
- For cross-provider comparison, read how to compare AI model prices.
- For gateway fees and routing controls, read AI gateway pricing.
- For finance operations, read AI API spend management.
- For architecture tradeoffs, read Claude API proxy vs multi-model router.
Frequently asked questions
What is the cheapest Claude API model in 2026?
Among the current active rows listed above, Claude Haiku 5.5 has the lowest listed token rates for prompts up to 100,000 tokens. For prompts over 100,000 tokens, Haiku 5.5 moves to a higher price tier, so long-context workloads should be measured carefully instead of assuming Haiku is always the cheapest route.
Does prompt caching reduce Claude API pricing?
Prompt caching can reduce effective Claude API cost when the same prefix is reused. You pay a higher write price to store the cacheable prefix, then a lower read price on later cache hits. It is strongest for repeated system prompts, tool definitions, policy packs, codebase context, and retrieved documents.
Does the Anthropic Batch API reduce cost?
Yes. Anthropic's Message Batches documentation says batch processing reduces costs by 50% and increases throughput for asynchronous work. Use it for jobs that do not require immediate responses, such as evaluations, enrichment, summarization backfills, and report generation.
Why does my Claude API bill exceed the calculator estimate?
The usual causes are longer-than-expected outputs, retries, low cache hit rate, long-context Haiku requests, data residency multipliers, and traffic that was assumed batchable but actually needed synchronous responses. Track each of those as separate lines in your usage ledger.
How should product teams budget Anthropic Claude API pricing 2026?
Budget by workload, not by provider. Pick a default model per route, measure output length, cache hit rate, retry share, and accepted-result rate for seven days, then approve spend caps by team, environment, and customer segment. That is the practical way to make Anthropic Claude API pricing 2026 predictable.
Final checklist
Before you approve a Claude API budget for 2026:
- Verify the live Anthropic pricing page on the day of approval.
- Separate input, output, cache write, cache read, batch, and retry lines.
- Run a seven-day workload test using real prompts and real acceptance rules.
- Move asynchronous work to Message Batches where the UX allows it.
- Add prompt caching only where the prefix is stable enough to hit repeatedly.
- Track cost per accepted result, not only token volume.
- Use a gateway and ledger when Claude is part of a multi-model production stack.
That is the difference between reading Anthropic Claude API pricing 2026 and actually controlling it.
