How to estimate what your Claude API feature will actually cost before you ship it

Quick answer: Claude API billing is per token, priced by model tier

Anthropic meters the Claude API by token, not by request or by minute. Every call carries two counts: input tokens, covering the user message plus anything your application attaches ahead of it (system prompt, chat history, retrieved documents, tool schemas), and output tokens, covering only the text Claude writes back. Anthropic publishes a separate rate for input and output on each model, and the output rate runs several times the input rate on every current Claude tier, so a short question that produces a long, detailed answer can end up costing more than a long question that gets a short one back. Model tier is the second lever. Claude Haiku prices at a fraction of Claude Opus for the same token counts, and picking the right tier for a task moves a bill more than any single prompt trick. The rest of this guide works through where the tokens actually go inside a real application, what a realistic multi-step task costs at official rates, and where the actual room to cut spend sits.

Where the tokens inside your app actually go

None of this is hidden. It is the ordinary cost of context: Claude only knows what is inside the request, so anything the model needs to see gets paid for again on every call that includes it. A support assistant that looks cheap in a demo with a two-line prompt looks very different in production once it carries a real system prompt, a knowledge-base excerpt, growing chat history, and a small tool-calling loop behind every user message.

• System prompt and tool schemas: fixed text your app sends on every call whether that particular turn needs it or not.
• Chat history: every earlier turn in a multi-turn conversation gets resent as input on each later call unless you truncate or summarize it first.
• Retrieved context: a RAG pipeline that attaches several document chunks per query can make retrieval, not the user's question, the largest line in the bill.
• Output length: a prompt with no length constraint lets Claude write as long a reply as it judges appropriate, and output tokens price higher than input on every tier.
• Tool calls and planning steps: one user request can trigger several model calls in sequence (plan, call a tool, read the result, continue), and each of those calls bills like a full request.

Worked example: what one completed task costs, not just one message

A single chat message rarely tells the real story, because most production Claude use is not one call per user action. Take a document-support agent that answers one user question by running four model calls: a planning call, two calls that each add a fresh tool result to the context, and a final answer call. Context grows across the loop, so the fourth call carries far more input than the first even though the user only asked one question. Summed across that loop, one completed task sends roughly 12,000 input tokens and returns about 1,200 output tokens, spread across the four calls. At 5,000 completed tasks a month, that is 60 million input tokens and 6 million output tokens, run through whichever Claude tier the agent is routed to. The table prices that exact monthly volume at Anthropic's official rates for three current tiers. The tier choice alone moves the bill by roughly 5x for the identical workload, which is why routing matters more here than trimming a few words from a prompt.

Why the invoice runs higher than the demo suggested

Individually, each of these is a small effect. Together, they explain why a workload that pencils out cheap in a spreadsheet often lands two to three times higher on the actual bill. The fix in every case is the same: log tokens per feature, per route, and per environment, not just a single monthly total, so a spike has an obvious owner.

• Context grows silently across a session. A prompt that cost pennies in week one can double or triple in token count by week eight as history, tool schemas, and retrieved content pile up, with no code change to explain it.
• Retries duplicate the charge. A timeout followed by an automatic retry bills the failed attempt and the successful one; aggressive retry logic can inflate a bill without improving a single answer.
• Agent loops multiply calls. A task that plans, calls a tool, inspects the result, and revises its plan can take four, five, or six model calls to finish, and every one of those calls bills like a full request, as the worked example above shows.
• Output drifts long without a cap. Skipping max_tokens, or setting it generously "just in case," lets verbose tasks like reports, code, or JSON generation drift toward the most expensive part of the rate card.
• Non-production traffic shares a production key. Staging, internal testing, and evaluation runs often authenticate with the same key as real users, so their usage never gets separated out until someone audits the invoice.

How Anthropic's billing shape compares to other token-billed APIs

Most large model providers, Anthropic included, bill on the same basic shape: a separate rate for input and output, one rate table per model, and a discount for content you send repeatedly. What actually changes your bill sits inside the mechanics, not the marketing copy.

Six ways to cut Claude API spend without downgrading the work that matters

The first five levers change how many tokens a task sends. The sixth changes what each token costs. APIsRouter is a pay-as-you-go, OpenAI-compatible gateway that prices Claude and other global models 20% below Anthropic's official list rates, with no subscription and no minimum commitment; the first top-up adds a 100% balance bonus, and the /topup checkout takes payment first and emails a working key with no signup form. The table below applies that discount to the same three Claude tiers from the worked example above.

• Cap max_tokens per route. A support-triage endpoint and a long-form report generator should not share the same output ceiling.
• Summarize or truncate old chat history instead of resending the full transcript on every turn.
• Reserve the flagship tier for the one step in a workflow that actually needs it, and route classification, extraction, and formatting steps to a smaller Claude tier.
• Cache any system prompt, tool schema, or reference document that repeats across many requests instead of resending it as fresh input every time.
• Tighten retry logic: a timeout budget and backoff instead of an immediate resend, with a cheaper fallback model for retries where the task allows it.
• Lower the rate itself, not just the token count, by pointing the same request format at a lower-priced endpoint for the same models.

Config example: point an OpenAI-compatible client at Claude

Switching where a request bills is a client configuration change, not a rewrite. The chat completions endpoint is OpenAI-compatible, so an existing OpenAI SDK integration only needs a new base URL, key, and model ID; message formatting, streaming, and tool-call syntax stay the same. Every response carries a usage object with the exact input and output token counts for that call, which is what should feed a per-route cost log instead of a single end-of-month total.

from openai import OpenAI

client = OpenAI(
    api_key="sk-APIsRouter-...",
    base_url="https://api.apisrouter.com/v1",
)

response = client.chat.completions.create(
    model="claude-sonnet-4-6",
    messages=[
        {"role": "system", "content": "Answer in three sentences or fewer."},
        {"role": "user", "content": "Summarize this month's token-cost checklist."},
    ],
    max_tokens=300,
)

print(response.choices[0].message.content)
print(response.usage)

FAQ