How Much Does Claude Code Actually Cost Per Month? Do the Math Before Finance Asks for a Budget

Accenture Caps Per-Head Budget at $29, Exposing the Structural Contradiction in AI Tool Pricing

According to 404 Media, Accenture notified a large number of employees that going forward, each person's monthly Claude budget is just $29. Previously, some employees were burning through as much as $1,000 per month — and now they're scrambling to figure out how to maintain their original usage intensity. Joseph Cox's post on X about the matter racked up over two million views, which tells you how many people felt a chill down their spine after seeing their bill.

Accenture spent years urging clients to invest heavily in AI, yet tightened its own spigot first. Ironic as that is, the token bill doesn't get a single cent cheaper because of it. The question genuinely worth asking is a boring but lethal one: how much does Claude Code actually cost per month, and how do you make that budget visible before the finance department comes knocking?

The Real Cost Structure of Claude Code

Claude Code has no standalone price tag. It's included in Anthropic's paid plans, and it shares a usage pool with regular Claude chat. Based on Anthropic's official pricing page (verified October 16, 2026):

Option	Price	What You Actually Get
Free	$0	No Claude Code
Pro	$20/mo, $17/mo billed annually	Includes Claude Code, with usage limits
Max	From $100/mo	5x or 20x Pro usage, plus monthly API credits
Team	Per seat	Admin console, centralized billing, user and org spend controls
Enterprise	$20/seat/mo + usage at API rates	Everything in Team, billed annually
Console (API)	Per token	No plan limits — and if you don't set a ceiling, there genuinely isn't one

Two details matter more than the sticker price.

First, subscription limits reset on a rolling five-hour window, with an additional weekly cap, and Anthropic doesn't publish a fixed message count. How long a plan lasts depends on the model, context length, and what the agent is doing. So "Pro is only $20" is true, but only half an answer.

Second, the API has no ceiling by default. The same page lists Opus 5.5 at $4 input / $20 output per million tokens, Sonnet 5.5 at $2 / $10, Haiku 5.5 at $0.10 / $0.50 (within 100K tokens), and beyond that $0.50 / $2.50. Claude Code's Opus 5.5 fast mode is listed at $8 / $40. These numbers look small — until an agent reads through your entire codebase forty times in one afternoon.

That's roughly how a $1,000 bill happens.

Why Coding Agents Burn Far More Cash Than Chat

A chat session consumes what you type plus the output you read. An agent consumes everything it reads to decide what to do next — over and over — most of which you never see.

LLMs are stateless: every turn resends the entire conversation. Coding agents amplify this problem along three dimensions:

• Naturally massive context: files, diffs, test output, tool definitions — the agent pulls it all in, because that's exactly how it works.
• Loops: run tests, read errors, edit code, run again. Each lap resends an ever-growing context.
• Sticky model selection: if the strongest model is the default, every boring rename is billed at frontier-model rates.

This isn't a bug — it's the product working as designed, which is precisely why it's easy to forget it's metering you.

Statelessness and context resending deserve their own section. LLM inference is stateless: the model itself remembers nothing about the conversation, and without you re-inserting the history, it has no idea what just happened. It's not like a human colleague who remembers the approach you discussed last week — every call is an amnesiac expert you have to bring fully up to speed. For a single-turn Q&A, the cost of resending is negligible. But a coding agent's task often spans dozens of tool-calling rounds, and each round must repackage the system prompt, tool definitions, accumulated files, and error messages into the input. Input tokens therefore don't grow linearly — they balloon roughly quadratically with the number of rounds, and the bill naturally ends up orders of magnitude higher than a single chat. This is also the underlying reason prompt caching is so dramatically cost-saving in agent scenarios.

How to Budget: Start from the Work, Not the Price List

A flat per-head number like $29 is a budget reverse-engineered from a price list. It's simple to administer, and it's wrong for almost everyone: too much for the person who opens Claude twice a week, nowhere near enough for the one reviewing what agents wrote all day.

A more sensible sequence:

1. Measure two normal weeks. Not a demo week — a normal week. Team and Enterprise have usage analytics; the API tells you token consumption on every response.
2. Group by how people work, not by title. Occasional users, daily users, "the agent is my pair programmer" — you'll typically see a long tail and a small, heavy cluster.
3. Give each group the cheapest option that won't interrupt them. Occasional users get Pro. Heavy users get Max or a premium seat, because a fixed monthly fee is far easier to explain to finance than an open-ended API bill. Automated pipelines go through the API, with hard limits.
4. Review monthly. Models and prices change. A set-and-forget budget will eventually surprise you.

If you're a solo developer, the logic is the same, only with smaller numbers: if Pro's five-hour limit keeps getting hit, that's a signal to try Max for a month and compare — not to quietly stack API credits on top and forget about them.

The mechanics of rolling windows and usage caps directly shape how you calculate a budget, so they're worth clarifying. Anthropic subscription plans don't hand you a monthly quota in one lump — usage resets on a rolling five-hour window, layered with a weekly cap. That means running out early in the month is different from running out late, and it means you can't simply divide the monthly total by working days to estimate daily capacity. Real usable capacity depends on how many tokens each request consumes, how long the context is, and whether it's a peak period — which is why no fixed message count is published. The right budgeting approach: run a real workload for a full week, log how often and when you hit the wall, then work backward to which tier you need — rather than dividing dollar figures off a price list.

How to Measure: An Invoice Is an Autopsy, Not a Measurement

If you can't measure it, you can't cap it. "Look at the invoice" isn't measurement — it's a post-mortem.

For the agents I build on the API, cost is read directly from the response: input tokens, output tokens, cache reads and writes. Log per call, tag with user or tenant and task, and "who's expensive, and why" goes from a guess to a GROUP BY query.

The genuinely useful metric isn't cost per user — it's cost per completed task: every merged PR, every fixed bug, every qualified lead. $1,000 a month is expensive if it bought a pile of redundant test loops; it's cheap if it replaced a week of human labor. Accenture's flat cap treats both cases the same, which is what I'd push back on if I worked there.

Prompt Caching is the most critical cost mechanism here and deserves its own explanation. In most agent inputs, the system prompt, tool definitions, and the code files being read are the repeated static portion. By default, these are billed as full-price input tokens on every call — effectively paying repeatedly for the same content. With caching enabled, these repeated prefixes are written to a cache, and subsequent calls that hit the cache are billed at a rate far below the input price — typically around one-tenth of it — while also reducing time-to-first-token. The trade-off is that caching has a write fee and a survival window; once the cache expires, it must be rewritten. For coding agents, the standard practice to maximize cache hit rate is to put the stable system prompt and tool definitions in the prefix and only the changing conversation and file diffs after them.

How to Set Caps Without Cutting the Useful Parts

Caps are best set in layers, each placed where money actually leaves the building:

• Plan limits: subscriptions have built-in caps; the five-hour window is a budget layer whether you like it or not.
• Admin spend controls: Team and Enterprise plans offer user- and org-level spend controls. Set them per group — don't hand everyone one flat number.
• API hard limits: set workspace limits on any Console key. An automated key with no ceiling is a typo away from becoming an invoice.
• In-code limits in your own agents: run a daily budget check before each call, and cap iterations on tool loops. While writing this article, my own WhatsApp bot had its tool-loop iteration cap set to 5, which is exactly what keeps a runaway loop from becoming a runaway bill.

Money-Saving Moves You Have Before You Even Set Caps

Most savings come from not paying for the same tokens twice:

• Prompt caching: enable caching for the static portion of context. Cache reads are far below input price on every model.
• Right model for the task: classification, renaming, and boilerplate don't need the strongest model — route them to Haiku or Sonnet.
• Shorten context: point the agent at the relevant files directly instead of making it rediscover your entire codebase every time.
• Batch the non-urgent stuff: Anthropic's Batch tier exists precisely for work nobody's waiting on.

Is $29 Enough?

For someone who occasionally uses Claude to draft or explain something, probably. Pro alone is $20. For someone who uses Claude Code as a daily coding agent, no — and the 404 Media report suggests the affected people already know that.

The lesson isn't "AI is too expensive" or "companies are too cheap." It's this: usage-based tools need budgets built from usage. Measure for two weeks, group by how people actually work, layer your caps, and track cost per completed task. It's far more boring than a memo — but at least your star engineers won't be raging about tokens on a Tuesday.

FAQ

How much does Claude Code cost per month?

As of October 2026, Claude Code has no standalone pricing. It's included in Anthropic's paid plans: Pro at $20/month ($17/month billed annually), Max from $100/month (5x Pro usage) up to a 20x tier, plus Team and Enterprise seats. Enterprise is listed at $20 per seat per month plus usage at API rates. You can also run Claude Code through a Console account at API prices per token — and without a monthly ceiling, there genuinely is no ceiling.

Which is cheaper, subscription or API?

For someone coding almost daily, a subscription is usually the more predictable choice: a fixed price, with usage resetting on a rolling five-hour window plus a weekly cap. The API is cheaper for light or bursty use, and it's the only option where you set every limit yourself — which also means nobody sets them for you. Measure two weeks of real usage before deciding.

How do I keep an AI coding agent from blowing the budget?

Set limits where money actually leaves — not in a spreadsheet: per-user or per-org spend limits in the Team/Enterprise admin console, hard workspace limits on API keys, and daily budget checks plus tool-loop iteration caps inside your own agents. Then log cost per task, so you know which work is worth spending tokens on.

One-line Summary

Accenture capping per-head Claude budgets at $29 exposes the structural contradiction between usage-priced AI coding tools and flat per-head budgets.

Paragraph Summary

Accenture squeezed its employees' monthly Claude budget down to $29, while some had previously consumed as much as $1,000 a month — a case that reflects the structural contradiction between usage-priced AI coding tools and traditional per-head budgeting. The article notes that Claude Code has no standalone pricing; it's bundled into Pro, Max, Team, and Enterprise plans and shares a usage pool with chat, while the API bills by token with no ceiling by default. Coding agents burn far more than chat because context is naturally massive, loops repeatedly resend an ever-growing context, and model selection is sticky. The sensible approach starts from how work actually happens: measure two normal weeks, group by usage pattern, give each group the cheapest option that won't interrupt their work, layer plan limits, admin spend controls, API hard limits, and in-code limits, and track cost per completed task rather than per user — while saving money through prompt caching, model routing, and context trimming.