Anthropic Claude API Pricing Per Token Explained

How Claude API pricing per token actually works

Anthropic bills the Claude API by tokens, not by requests or by time. Every call you make is split into two separately-priced buckets: the tokens you send in (your prompt, system instructions, conversation history, tool definitions) and the tokens Claude generates back. You're charged for both, usually at different rates, and the rate itself depends on which model you call.

That's the short answer to "how much does the Claude API cost per token": it's a per-model, per-direction price, measured per million tokens, applied to the exact token counts Anthropic reports back in the response. There's no flat monthly fee from Anthropic itself — your bill is the sum of every input and output token across every request you make that month. Prices change over time and vary by model tier, so the most reliable source for current numbers is Anthropic's own pricing page rather than any blog post, including this one.

Input tokens vs output tokens

Output tokens almost always cost more per million than input tokens — generation is more computationally expensive than reading. This has a practical consequence for how you design prompts:

• A long system prompt or large document pasted into context is relatively cheap per token, but it adds up fast if you resend it on every turn of a conversation.
• A short prompt that triggers a long, verbose answer can cost more than a long prompt that gets a terse answer back.

If you're building something chat-like, this asymmetry matters more than the headline per-token number. Trimming unnecessary output (asking for JSON instead of prose, capping max_tokens, instructing the model to be concise) often saves more money than switching models.

Model tiers change the math

Anthropic offers multiple Claude model tiers (lightweight, mid-tier, and frontier), and each tier has its own price point:

• Lightweight models are the cheapest per token and are a good fit for classification, extraction, routing, or high-volume simple tasks.
• Mid-tier models balance cost and capability for most production chat, summarization, and agentic workloads.
• Frontier models cost the most per token but handle complex reasoning, long multi-step tasks, and nuanced writing better.

Picking the right tier per task — rather than defaulting to the most capable model everywhere — is usually the single biggest lever on your actual spend. A router that sends simple requests to a lightweight model and only escalates to a larger one when needed can cut token costs dramatically without a noticeable drop in quality for most of your traffic.

Costs you might not notice

A few things inflate token usage in ways that don't show up until the invoice arrives:

• System prompts sent on every call. If your system prompt is 2,000 tokens and you make 10,000 requests a day, that's 20 million input tokens a day before the user even says anything.
• Full conversation history. Resending the entire chat transcript on every turn means early messages get billed over and over.
• Tool definitions and schemas. Each tool you register adds input tokens on every call, even if the model doesn't use it.
• Prompt caching and batch processing. Anthropic offers mechanisms that discount repeated context or non-urgent batch work — worth checking if your workload has stable prefixes or can tolerate asynchronous processing.

Estimating your bill before you build

A simple way to get a cost estimate without waiting for a real invoice is to log token usage from every response and multiply by current per-million rates:

function estimateCost(usage, rates) {
  const inputCost = (usage.input_tokens / 1_000_000) * rates.input;
  const outputCost = (usage.output_tokens / 1_000_000) * rates.output;
  return inputCost + outputCost;
}

// usage comes from the API response's usage object
// rates comes from the current published pricing for the model you called
const cost = estimateCost(usage, { input: 3.0, output: 15.0 }); // example rates only
console.log(`$${cost.toFixed(4)} for this request`);

Run this against a representative sample of real traffic — not synthetic test prompts — and you'll get a far more accurate monthly projection than any generic calculator.

Where SubToAPI fits into cost control

Token pricing is unavoidable if you're calling Claude directly, but managing it across a team adds its own overhead: tracking who's spending what, rotating keys safely, and reasoning about per-model usage across projects. SubToAPI turns your existing Claude access into a standard HTTPS API with application keys (sub_live_...), and every response includes usage metadata so you can log and attribute token spend per key, per project, or per team member without building that instrumentation yourself.

On top of that, SubToAPI's own cost is predictable and separate from token usage — flat per-seat pricing (Solo at €9, Team at €19/seat, Scale at €49/seat) rather than a percentage markup on tokens, with a free trial at /signup. If you want the exact request/response shape, the /docs/messages and /docs/streaming pages show how usage data comes back on both standard and streamed calls, and /pricing has the current seat tiers.

Practical ways to lower your per-token spend

• Cache or summarize long conversation history instead of resending it in full.
• Use the smallest model tier that reliably passes your quality bar, and only escalate when needed.
• Cap max_tokens to stop runaway generations.
• Ask for structured, concise output formats (JSON, bullet lists) instead of open-ended prose when you only need specific fields.
• Batch non-urgent work if your use case allows async processing at a discount.
• Track usage per endpoint or feature so you can see which part of your product is actually driving cost.

Questions

Is Claude API pricing the same for every model? No. Each model tier has its own input and output rate per million tokens, with lightweight models priced lowest and frontier models priced highest. Always check current rates for the specific model you're calling.

Do input and output tokens cost the same? Usually not — output tokens are typically priced higher than input tokens because generation is more compute-intensive than processing a prompt. Long, verbose responses can cost more than long prompts with short answers.

How can I predict my monthly Claude API bill? Log the usage object from real API responses (not test prompts), multiply input and output token counts by the published per-model rates, and extrapolate from a representative sample of your actual traffic over a few days.