Claude Code Pricing and the Real Cost of LLM Tokens

TL;DR

Claude Code pricing is usage-based: you pay for the tokens the model reads and writes. On the Claude API, Claude Opus 5 costs $5 per million input tokens and $25 per million output tokens. Claude Sonnet 5 costs $2 and $10 per million (announced as introductory pricing, now confirmed as the standard rate), and Claude Haiku 4.5 costs $1 and $5. Subscription plans bundle usage into a monthly fee, but the meter underneath is the same: every request is billed by what the model processes. Which means the real lever on your Claude Code bill is not the rate card. It is how many tokens each request carries, and most teams carry far too many. Sentra, the organizational memory layer, is the structural cost lever covered after the plan arithmetic below.

How much does Claude cost per month? Every plan compared

Anthropic sells Claude two ways: a subscription that bundles usage into a flat fee, and the API, which bills per token. Claude Code is included in every paid subscription tier. These are the published prices as of August 2026.

Two things in that table trip people up. Max is a personal plan and is monthly only, so there is no annual discount to negotiate. And the Max multipliers are per session rather than per month, so they raise the ceiling on a single long agentic run rather than granting a monthly pool you can spend however you like.

Is Claude Team worth it compared to buying Pro seats individually?

On price alone, no. Team Standard costs $25 per seat monthly against $20 for Pro, and $20 per seat annually against $17. That is 25 percent more per person on monthly billing and 18 percent more annually, and the reason to pay it is administrative rather than economic: one invoice, centrally managed seats, shared projects, and the admin controls that make offboarding a click instead of a chase. Team also has a two seat minimum. If those things are worth $3 to $5 per person per month to you, buy Team; if you are three developers who already expense your own subscriptions, Pro seats are cheaper and the difference is real.

Claude Code subscription vs API rates: which is cheaper?

This has a break-even you can compute rather than argue about. Take a substantial agentic request at roughly 20,000 input tokens and 1,500 output tokens. On Claude Opus 5, at $5 per million input and $25 per million output, that request costs about $0.14 on the API. On Claude Sonnet 5, at $2 and $10, it costs about $0.055.

Read it as a threshold. A developer who makes more than about seven serious Opus 5 agent calls in a working day is already better off on a $20 subscription than on API billing, which is why almost every full-time user of a coding agent should be on a plan rather than a key. The API wins in the opposite cases: bursty or automated workloads, anything you want to run in batch at half price, and any product you are building on top of Claude, where per-seat licensing does not apply. Both numbers assume the request shape above, so recompute with your own average if your context payloads are larger, and note that larger payloads move the break-even in favour of the subscription.

What is the cheapest way to reduce Claude token costs for a team?

Four levers exist, and they are not equally powerful. Ranked by what they actually do: route easy work to a smaller model, which is usually the largest single reduction available and the one teams resist longest; turn on prompt caching, where a cache read costs 0.1x the base input rate against a write at 1.25x for five minutes or 2x for an hour, so a stable prefix gets about 90 percent cheaper to resend; use the Batch API for anything asynchronous, which is a flat 50 percent off both input and output; and send less context in the first place. The first three lower the price of the tokens you send. Only the fourth lowers how many you need to send, which is why it is the only one that keeps working as your corpus grows, and it is the lever the rest of this page is about.

How does Claude Code pricing scale for a growing team?

Sentra, the organizational memory layer, publishes this breakdown because the budgeting question arrives before the optimization question. At Anthropic's current seat prices (August 2026: Team Standard $25 per seat monthly or $20 billed annually, Team Premium $125 monthly or $100 annually, both including Claude Code), a team's subscription floor scales like this.

Two honest caveats on that table. First, seats are the floor, not the bill: heavy agentic use runs into plan limits, and teams that overflow onto API rates pay by the token, which is where context size dominates. Second, the per-seat price is fixed by Anthropic, so the only line a team controls is tokens per request. You can model your own fleet, including the effect of prompt caching and a memory layer, with our agent token cost calculator at /tools/agent-token-cost-calculator.

What Claude Code Pricing Actually Charges You For

Every request to Claude Code has two cost drivers: the tokens you send in and the tokens you get back. Most teams focus on the second one, trying to get shorter, cleaner outputs. But the input side is usually where the real spend hides, because input volume dwarfs output volume in agentic work.

That input is not just your question. It is the system prompt, the retrieved documents, the conversation history, the code snippets, the tool outputs, and whatever else got stuffed in to give the model a fighting chance at answering correctly. In agentic workflows especially, that context payload can outweigh the actual question by orders of magnitude.

So when people ask how to reduce Claude Code costs, the honest answer is rarely "use a cheaper model." It is "stop sending the model so much raw material to sort through every single time."

Why Token Costs Spiral: The Re-Reading Problem

Most systems handle context with retrieval augmented generation. A query comes in, the system searches a vector store, pulls back a pile of chunks that seem relevant, and stuffs them into the prompt. The model then has to read all of it, figure out what actually matters, resolve any contradictions, and guess at relationships that were never made explicit.

This happens on every single query. The same documents get re-read, the same ambiguities get re-resolved, sometimes differently each time. Every chunk you retrieve is a chunk you pay to process, every time, forever. Scale that across thousands of queries a day and the token bill grows in direct proportion to how sloppy your context assembly is.

The Fix: Resolve Meaning Once, Not Every Query

The alternative is to stop treating context as something you rebuild at query time and start treating it as something you resolve once, upfront, and keep current.

This is the core idea behind Sentra. Instead of retrieving raw chunks and asking the model to make sense of them on the fly, Sentra resolves meaning at write time. Facts, relationships, and changes get processed into a bi-temporal context graph the moment they happen, not the moment someone asks a question about them. Bi-temporal means Sentra tracks both when something became true and when the system learned about it, so the graph knows the difference between what changed last week and what you just found out.

By the time a query arrives, the hard work is already done. The model gets a clean, resolved answer instead of raw material to sift through. Fewer tokens go in, because there is less noise to send. Fewer tokens get wasted on the model reasoning its way through contradictions, because the contradictions were already resolved before the question was ever asked.

What This Looks Like in Practice

The results show up in benchmarks, not just in theory. On Terminal-Bench 2.1, this approach produced 72.6% lower model cost and 41.2% fewer tokens while accuracy rose from 83.37% to 88.31% mean reward across 445 trials. That is not a tradeoff between cheap and correct. Resolving context once, correctly, at write time means the model spends its tokens answering instead of untangling.

That is the real lever for Claude Code cost optimization. It has less to do with prompt engineering tricks or picking a smaller model for simple tasks, and everything to do with what you feed the model in the first place.

The Bottom Line

Claude Code pricing charges you for every token the model has to process, and retrieval-style context assembly guarantees you pay that price over and over for the same unresolved material. Sentra is the layer that fixes this: context infrastructure, the company brain that continuously resolves what your organization knows and hands models a clear picture instead of a search problem. Fixing token cost is not about squeezing the model harder. It is about giving it less to figure out. Resolve meaning once, keep it current, and let the model spend its tokens on the actual question instead of the archaeology required to answer it.