How Much Does Claude Code Cost? Every Plan and Price

I've watched two different people describe Claude Code's price in the same week: one said it costs $20 a month, the other said their team spent $2,000 per engineer. Both were right. Claude Code doesn't have one price. It has two entirely different billing models bolted onto the same tool, and which one applies to you depends on how you signed in, not on anything you typed into the terminal.

How much does Claude Code cost right now?

Here's the full table, subscription and API side by side, straight from Anthropic's pricing page and its Claude Code cost documentation.

Claude Code has no price tag of its own: you pay for it through a Claude subscription or through raw API tokens, and those two bills can look nothing alike. A subscription is a flat monthly fee with a usage allowance behind it. The API is metered, with no ceiling unless you set one yourself. Everything below explains which one you're actually on, what changes the number, and why this table has already shifted more than once in 2026 alone.

How has Claude Code's pricing changed in 2026?

If the table above feels like it could be out of date by the time you read it, that instinct is correct. Anthropic changed Claude Code's pricing and limits five separate times in the first half of 2026, and one of those changes was reversed within a day.

Two of these are worth slowing down on, because they're the ones most likely to trip up anyone budgeting off an older article or a cached memory of "what Claude Code costs."

The April episode started when Anthropic quietly pulled Claude Code out of the $20 Pro tier on its public pricing page, with no advance notice. People noticed by comparing archived versions of the page against the live one. Amol Avasare, Anthropic's Head of Growth, said on X that it was "a small test on ~2% of new prosumer signups," then reversed the public-facing pages the next day, admitting "it was a mistake that the logged-out landing page and docs were updated for this test" (source: Pasquale Pillitteri's reporting on the incident). If you read a claim anywhere that Pro no longer includes Claude Code, it's either describing that 24-hour window or it's wrong.

The May-June episode is bigger and still relevant to how you should budget today. On May 14, 2026, Anthropic announced that programmatic usage, meaning the Claude Agent SDK, the headless claude -p command, Claude Code's GitHub Actions integration, and third-party apps authenticating through a Claude subscription, would stop drawing from your normal Pro, Max, Team, or Enterprise allowance starting June 15. In its place: a separate monthly dollar credit billed at standard API rates, with no rollover, sized at roughly $20 for Pro, $100 for Max 5x, and $200 for Max 20x. Then, on the day it was supposed to take effect, Anthropic paused it. The company's help center notice, as reported by Digital Applied, stated plainly that "the planned move of Agent SDK, claude -p, and third-party app usage to a separate monthly credit is no longer happening." Anthropic said it's reworking the plan to "better align it with actual usage patterns" and will give advance notice before trying again.

Nothing about how headless Claude Code, GitHub Actions, or the Agent SDK bills you has actually changed as of this writing: all of it still draws from your regular subscription allowance, exactly as before. But the announcement itself tells you something the price table can't: Anthropic considers programmatic usage a cost center worth separating out, and it tried to do exactly that with three weeks of notice. Treat the next section as a description of today's rules, not a permanent contract.

Is Claude Code included in a subscription, or billed separately?

Both, and the difference comes down to how you authenticated claude the first time you ran it.

A $17-to-$20-a-month Claude Pro subscription includes Claude Code at no extra charge, right up until you hit your usage window. Sign in with your claude.ai account, and Claude Code draws from a shared allowance with Claude chat and Cowork. That allowance resets on a rolling five-hour window and a weekly window, according to Anthropic's own cost documentation, and as of May 6, 2026, that five-hour window is permanently twice as generous as it used to be, with peak-hour throttling removed for Pro and Max entirely. You don't see a per-request dollar figure. You either have room left in the window or you've hit a limit and need to wait for the reset, upgrade to Max, or turn on usage credits to keep going past your plan's ceiling.

Sign in with an API key from the Claude Console instead, and there's no allowance at all. Every input token, every output token, every tool-use overhead token gets metered and billed at the published per-model rate, the same rates a Console customer building a production application pays. There's no separate "Claude Code price" on the API side; it's the same token meter as everything else running on the Claude API.

On Team and Enterprise, the split is by seat tier, not by choice. Claude Code only works on a Team Premium seat ($100/month annual, $125/month monthly) or on Enterprise; a Standard Team seat gets Claude chat and Cowork but not Claude Code at all. Enterprise itself charges a flat $20 per seat and then bills the actual usage at API rates on top, which functionally makes Enterprise closer to the API model than to Pro or Max, just with an admin able to set org-wide spend limits instead of every developer managing their own.

There's a fourth path worth knowing about even if you never touch it yourself: Amazon Bedrock, Google Cloud's Agent Platform, and Microsoft Foundry can all run Claude Code, billed entirely through your cloud provider instead of Anthropic. That's involved enough to earn its own section below.

Does headless Claude Code, GitHub Actions, or the Agent SDK cost extra on a subscription?

Not right now, and this is worth a dedicated answer because it's the one part of Claude Code's pricing that's actively in flux while you're reading this.

As covered above, Anthropic announced on May 14, 2026 that it would carve programmatic usage out of the normal subscription pool on June 15. That covers four specific surfaces: the Claude Agent SDK (what you'd use to build a custom agent on top of Claude), the headless claude -p command (scripting Claude Code from a shell script or cron job without the interactive terminal UI), Claude Code's GitHub Actions integration (running Claude inside CI to review PRs, fix failing tests, or triage issues automatically), and any third-party app that authenticates using your Claude subscription rather than its own API key. All four of those currently draw from the exact same rolling five-hour and weekly allowance as a normal interactive terminal session.

The reason Anthropic wanted to split this out in the first place is worth understanding even though the split didn't happen: reporting on the announcement described subscriptions as subsidizing heavy automated usage by roughly 15 to 30 times the actual API cost of that usage, because a subscription's flat price was designed around a human typing into a terminal, not a cron job firing off dozens of unattended runs a day. A CI pipeline that runs Claude Code on every pull request, all day, every day, looks nothing like a developer's interactive session, but until June 15 was billed as if it were.

Then the pause happened. Anthropic's help center told subscribers, in effect, that this is on hold: "nothing changes for now." No separate Agent SDK credit exists. No new dollar figure appears anywhere in your billing. If you've set up Claude Code in a GitHub Actions workflow, or you're calling the Agent SDK from a script, or you've connected a third-party tool through your Claude login, it's still spending against the same window your terminal sessions use.

If you're running Claude Code headless in CI, in a cron job, or through the Agent SDK today, budget it against your normal subscription allowance, not a separate line item, because that's still how it's billed. But build in the assumption that this could change with three weeks of notice, because it already has once. If you're running automation at real scale, whether that's dozens of PRs a day or a fleet of scheduled agents, the safer long-term move is to authenticate that automation with an API key on the Console instead of a subscription login. API usage was never eligible for this kind of pooling in the first place, so it's the one path Anthropic can't quietly redraw around you.

How much do Claude Code's actual API tokens cost?

If you're on the API or Console, or you're an admin trying to forecast what a team will spend, this is the table that actually determines your bill. Rates are per million tokens (MTok), current as of Anthropic's published pricing.

Two modifiers change what you actually pay against that table. Prompt caching, which Claude Code turns on automatically, charges 1.25x the base input rate to write a 5-minute cache and just 0.1x the base input rate to read from it, so a session that repeatedly reuses the same system prompt or file context pays a fraction of the sticker rate on most of its input tokens. The Batch API, less relevant for interactive Claude Code work but relevant if you're scripting bulk operations with claude -p, cuts both input and output rates in half, and that discount is identical whether you're calling the direct Anthropic API or routing through a cloud provider.

Anthropic's own guidance puts typical Claude Code spend at $13 a day and $150 to $250 a month per developer, with 90 percent of users staying under $30 on any single day. That's the number to anchor on if you're an admin trying to budget a rollout before it happens, not the extreme cases covered further down.

Should you run Claude Code through AWS Bedrock, Google Vertex AI, or Microsoft Foundry instead?

For most individual developers, no, this section doesn't apply to you. For an engineering org that already routes spend through one of the big three clouds, it might be the more sensible default, and it's worth understanding before you assume "the API" always means Anthropic's own servers.

The core fact first: base per-token pricing for Claude models is identical whether you call Anthropic's API directly or route through AWS Bedrock, according to a detailed rate comparison from Hikari's Notebook. Claude Opus, Sonnet, and Haiku all bill the same input and output rates on Bedrock as they do on the Claude Platform. Prompt caching rates match too, both the 5-minute and 1-hour cache tiers, as does the Batch API's 50 percent discount. So switching to Bedrock isn't a way to pay less per token.

What does change is everything around the token rate:

• Regional surcharges on Vertex AI. Google Cloud's regional endpoints, as opposed to its global endpoint, carry roughly a 10 percent premium over base pricing, and cross-region inference can add another surcharge on top of that. If your org needs Claude requests to stay inside a specific region for compliance reasons, budget for that premium explicitly.
• Feature rollout lag. New Claude capabilities, extended thinking controls and new model releases among them, land on Anthropic's own API first. Bedrock, Vertex AI, and Azure typically get the same feature weeks later. If you're chasing the newest model or a newly announced pricing tier, the direct API sees it first every time.
• Billing integration. Bedrock usage shows up as line items inside your existing AWS bill, with IAM and audit-log integration that a lot of enterprise finance and security teams already rely on. That's a real advantage if you're already deep in AWS's cost-allocation tooling and don't want a second vendor relationship to track. The same logic applies to Vertex AI inside GCP billing and Microsoft Foundry inside Azure billing.
• Where you see and cap spend. According to Anthropic's own Claude Code documentation, usage through Bedrock, Google Cloud's Agent Platform, or Microsoft Foundry is billed entirely to your cloud account: you see it in your cloud billing console, and you cap it with your cloud provider's own budget controls, not Anthropic's usage-credit system. Anthropic doesn't receive usage metrics from cloud-routed traffic, so its own analytics dashboards and the Claude Code Analytics API don't cover it either.
• Per-user attribution takes extra setup. Because the cloud provider only sees aggregate token usage, not "which developer ran this," getting a per-engineer cost breakdown on Bedrock or Vertex requires either exporting OpenTelemetry metrics from each developer's machine to your own observability stack, or routing traffic through a self-hosted LLM gateway such as LiteLLM, which tracks spend by API key. Neither is automatic the way the Claude Console's per-user dashboard is on a direct API setup.

The practical decision rule: if your organization already has a large committed spend or reserved-capacity discount with AWS, GCP, or Azure, routing Claude Code through that cloud can make sense purely for consolidated billing and existing compliance tooling, not because the tokens themselves are cheaper. If you don't have that existing relationship, the direct Anthropic API or a subscription plan gets you the newest features first and simpler per-user cost visibility out of the box.

What does a real Claude Code session cost, in dollars?

Token rates are abstract until you attach them to an actual session. Here's the math, using Anthropic's published rates, not a benchmark or a claimed real bill, just the table above applied to plausible token counts.

That $0.55 middle row isn't a hypothetical. It's the exact example Claude Code's own /usage command shows in its documentation for a session that ran 6 minutes of API time across 6.5 hours of wall-clock time, mostly served from cache. It's also the clearest illustration of why two developers on the same plan can post wildly different bills: the difference between $0.25 and $4.00 in the table above isn't a different task, it's a different model choice and a different amount of uncached context, applied to roughly the same work.

Three more cost mechanics worth knowing, because none of them show up until you go looking for them:

Extended thinking is billed as output tokens, and it's on by default. For complex planning or reasoning tasks, Claude's default thinking budget can run into the tens of thousands of tokens per request, all charged at the model's output rate, which is typically five times its input rate. A routine task that doesn't need deep reasoning still pays for it unless you lower the effort level with /effort, disable thinking in /config, or set a smaller budget with the MAX_THINKING_TOKENS environment variable. On a model with adaptive reasoning, that budget setting is ignored, so effort levels are the lever there instead.

Agent teams multiply cost roughly by team size, not by a flat 7x. Spawning multiple Claude Code instances to work a problem from different angles is a real capability, and Anthropic's own documentation puts the token cost at approximately 7x a standard session when teammates run in plan mode, because each teammate maintains its own full context window. A four-person agent team tackling that $0.25 focused bug fix from the table above, run in parallel with each teammate exploring independently, doesn't cost $0.25. It's closer to $1.75, and it keeps costing that much for every teammate still active until each one exits or the session ends.

Even an idle session isn't quite free. Background functionality, conversation summarization for /resume and status checks from commands like /usage, consumes tokens in the background, typically under $0.04 per session according to Anthropic's documentation. It's not the line item that blows a budget, but it explains why a bill is never exactly zero even on a day you barely touched the terminal. Connected MCP servers add a smaller but similar kind of persistent cost: tool names, even when Claude Code defers full tool definitions until they're used, still occupy a sliver of context on every single turn for as long as that server stays connected.

What rate limits should a growing team plan for?

Cost and rate limits are two different ceilings, and teams that only budget for one get blindsided by the other. Anthropic's Claude Code documentation publishes recommended tokens-per-minute (TPM) and requests-per-minute (RPM) allowances per user, scaled to organization size, for API and Console customers setting up rate limits.

The per-user recommendation shrinks as the team grows because concurrent usage across a large organization is lower than a naive per-seat multiplication would suggest. Anthropic's own example: for 200 users, you'd request roughly 20k TPM per user, which works out to 4 million TPM total, not 200 times the 1-5-person tier's 200k-300k. That's a genuinely different number from what most people guess on their first try.

These limits apply at the organization level, not as a hard per-person cap, so an individual developer can temporarily burn through more than their calculated share while everyone else on the team is idle. That's normal, not a sign something's misconfigured. The one scenario Anthropic flags as needing a manual bump above the table: a live training session or workshop where an unusually large fraction of a team is running Claude Code concurrently, since that spikes well past the assumption the sizing table is built on.

Which Claude Code plan should you pick?

Match the plan to how you actually work, not to the label.

How much should an enterprise budget per developer?

If you're the person who has to put a number in a spreadsheet before a Claude Code rollout, not after one, Anthropic's own admin-facing guidance gives you somewhere to start instead of guessing.

Start smaller than the eventual rollout. Anthropic's costs documentation explicitly recommends starting with a small pilot group and using tracking tools to establish a baseline before wider rollout, rather than enabling Claude Code org-wide on day one and finding out the real number from the first invoice. That's the single most concrete lesson buried in the Uber and Microsoft stories below, told in advance instead of in hindsight.

Budget differently for a coding seat than a chat seat. Anthropic's Enterprise consumption guide, written specifically for admins planning spend, makes the point directly: each Claude Code turn carries file contents, tool calls, and multi-step reasoning, so one debugging session can consume more than a day of ordinary Claude chat use. If your finance model treats a Claude Code seat like a slightly heavier version of a chat seat, it will underestimate the real number.

Use the right reporting surface for your setup, because they're not interchangeable:

• On Team, export the spend report CSV from org analytics for token usage and estimated spend per user and per model, updated daily. This only covers usage-credit spend, once usage credits are turned on; usage inside the seat allowance itself isn't metered in dollars.
• On Enterprise, the Analytics API returns per-user usage and cost reports across every Claude surface, including Claude Code, programmatically, so you can pipe it into whatever dashboard your finance team already uses.
• On Console (API), the Console dashboard shows spend and accepted code changes per member, and the Claude Code Analytics API returns the same daily per-user metrics with an Admin API key.
• On a cloud provider, none of the above apply; you're back to OpenTelemetry export or an LLM gateway for per-user attribution, as covered above.

The one number worth writing down before a rollout meeting: $150 to $250 per developer per month is Anthropic's own stated average across enterprise deployments, and 90 percent of active users stay under $30 on any single day. The other 10 percent, and especially the outliers inside that 10 percent, are exactly what the next two sections are about.

Why did Uber and Microsoft's Claude Code bills spiral?

These aren't hypothetical cautionary tales. Both happened in 2026, both are publicly reported, and both trace back to the exact subscription-versus-API split covered above.

Uber rolled Claude Code out to its engineering organization starting in December 2025. Adoption climbed fast: 32 percent of engineers using it by February, 84 percent by March, and 95 percent using some AI coding tool monthly by spring, with roughly 70 percent of committed code touched by AI by that point, according to Forbes' reporting on the rollout. Uber's CTO, Praveen Neppalli Naga, confirmed to The Information that the company burned through its entire 2026 AI budget, against a $3.4 billion 2025 R&D base, in just four months. Reported per-engineer costs ran $150 to $250 a month on average, the same range Anthropic's own guidance cites, but power users landed between $500 and $2,000 a month. Naga himself reportedly watched a two-hour personal demo session cost $1,200 in API spend, a stark illustration that "agentic" usage, where Claude runs many tool calls and reads many files across a long session, scales cost very differently than a single chat message.

Microsoft's story is the mirror image: a decision to pull back, not just a surprise bill. The company gave thousands of engineers across its Experiences + Devices division, the group behind Windows, Microsoft 365, Outlook, Teams, and Surface, access to Claude Code starting in December 2025 alongside GitHub's own Copilot CLI, explicitly to benchmark the two. Rajesh Jha, the division's Executive Vice President, explained the resulting decision in an internal memo: "When we began offering both Copilot CLI and Claude Code, our goal was to learn quickly, benchmark the tools in real engineering workflows, and understand what best supported our teams." Microsoft is winding down internal Claude Code access by June 30, 2026, moving those engineers onto Copilot CLI instead, with Jha framing it as a toolchain decision: "Copilot CLI has given us something especially important: a product we can shape directly with GitHub for Microsoft's repos, workflows, security expectations, and engineering needs." Reporting on the decision has widely noted that the timing, right at Microsoft's fiscal year end, and the token-billing costs that became visible once flat-seat pilot pricing gave way to usage-based billing, plausibly shaped the decision alongside the stated toolchain rationale.

Token-based billing is exactly why the same tool can cost one developer $20 a month and another developer $2,000. Neither Uber nor Microsoft's engineers did anything unusual. They used Claude Code the way it's designed to be used: agentically, across long sessions, reading real codebases. The lesson isn't "don't use Claude Code at scale." It's "don't roll out token-metered software to thousands of people without the visibility and caps to know what it's actually costing until the bill arrives." Uber and Microsoft weren't even the most extreme case reported in 2026.

What's the most extreme Claude Code bill on record?

$500 million, in a single month, at one unnamed enterprise. Axios first reported it, and the figure was picked up widely from there, including by Yahoo Finance.

The mechanism was almost embarrassingly simple: the company gave its employees unlimited access to Claude, with no usage caps or spend limits configured anywhere, at an organization large enough that thousands of people were using it concurrently. Agentic tools like Claude Code can consume up to 1,000 times more tokens than a basic chat query, since a single coding session might read dozens of files, run tests, and iterate across many tool calls, and none of that showed up anywhere until the invoice did.

That single incident wasn't alone in the reporting. The same coverage noted a Google Cloud customer who received an $18,000 surprise bill from unmonitored agentic AI usage, and Amazon reportedly scrapped its own internal AI usage-tracking system after discovering employees were gaming the metrics it was built to measure, undermining the very tool meant to catch cost problems early.

Every one of these stories, the $500 million bill, Uber's four-month budget burn, Microsoft's pullback, and the $18,000 Google Cloud surprise, traces back to the same root cause: flat seat licensing and unlimited access hid the real per-token cost until usage had already compounded past the point of easy correction. None of these companies did anything technically wrong. They just applied the spending discipline they'd use for a SaaS seat license to a metered utility instead, and a metered utility doesn't forgive that assumption. Most enterprises still don't apply to AI tooling the same controls, per-engineer caps, real-time consumption alerts, budget thresholds that block instead of just notify, that DevOps teams have applied to cloud compute for a decade.

Your Claude Code bill is higher than expected: what do you check first?

If you're past prevention and already staring at a number that doesn't make sense, work through this in order. Each step rules out one specific cause before you move to the next.

1. Run /usage and read the breakdown, not just the total. On a subscription plan, /usage attributes recent usage to skills, subagents, plugins, and individual MCP servers as a percentage of the total, and you can press d or w to toggle between the last 24 hours and the last 7 days. This alone answers "what's actually eating my window" for most people before they need to guess.
2. Check for a session that never got cleared. A Claude Code process that's been open for days, accumulating file reads and tool output from several unrelated tasks, reprocesses all of that stale context on every single turn. This is the single most common cause of an inflated bill that isn't explained by anything unusual in the work itself.
3. Check which model actually ran. Opus costs 2.5x Sonnet 5's input rate and 2.5x its output rate. If Opus got left as the default for routine work, or a teammate switched to it mid-session and forgot to switch back, that alone can double or triple a bill with no change in the work being done.
4. Check for an agent team still running. Each teammate in an agent team keeps consuming tokens until it exits or the session ends, and Anthropic's own guidance puts the multiplier at roughly 7x a standard session. A team spun up to investigate something and then left idle, rather than shut down, keeps billing the whole time.
5. Check the extended thinking budget. A high effort level or a large MAX_THINKING_TOKENS value applied by default to simple, routine tasks bills thinking tokens at the output rate on every single request, whether or not the task actually needed that depth of reasoning.
6. Check the authoritative dashboard for your setup, not just /usage's local estimate. The dollar figure /usage shows is computed locally from token counts and can differ from your actual bill. For API and Console accounts, the Claude Console usage page is the source of truth. For Bedrock, Vertex AI, or Microsoft Foundry, check that cloud provider's billing console instead, since Claude Code doesn't send usage metrics back to Anthropic for cloud-routed traffic.
7. Confirm whether headless, GitHub Actions, or Agent SDK usage still draws from your normal allowance. As covered above, it does today, but Anthropic already announced this would change once. If you're reading this after Anthropic revives the paused Agent SDK billing split, a chunk of what used to be inside your subscription might now show up as a separate credit line.

How do you keep Claude Code costs under control?

Five habits cover almost everything, whether you're one developer on Pro or an admin rolling this out to a hundred people.

Check /usage before you guess. It shows real token counts and a locally computed dollar estimate for your current session, plus, on a subscription plan, a breakdown of what's eating your plan allowance by skill, subagent, plugin, and MCP server. For authoritative billing on an API account, the Claude Console's usage page is the source of truth, not the CLI's estimate.

Set a spend limit before you need one. On Pro or Max, /usage-credits opens a dialog to turn on usage credits and cap your monthly spend. On an API or Console account, set a workspace spend limit instead. On Team or Enterprise, an admin sets this at the organization, group, or individual level, which is the exact control Uber and Microsoft's rollouts were missing during their pilot phases, and the exact control that would have stopped the $500 million bill above at a fraction of that number.

Default to Sonnet, reserve Opus. Sonnet handles most coding tasks well at a fraction of Opus's per-token cost. Save Opus for genuinely hard architectural decisions or multi-step reasoning, and set model: haiku on subagent configurations doing simpler, high-volume work.

Clear between unrelated tasks. A session that's accumulated file reads and tool output from three unrelated pieces of work keeps paying to reprocess all of it on every turn. /clear between tasks and /compact at a natural checkpoint both cut this down; the context management guide covers exactly when to reach for which one.

Watch agent teams specifically. Multiple parallel Claude Code instances, spawned to work a problem from different angles, use roughly seven times the tokens of a single session according to Anthropic's own documentation, because each teammate maintains its own separate context window. That's a real capability worth using deliberately. It's a poor default to leave running unattended.

If you're writing prompts that make Claude explore more of your codebase than the task actually needs, that inflates cost the same way an oversized session does; the techniques in how to prompt Claude for better code output apply directly here, since a specific, scoped prompt reads fewer files than a vague one. And if you're connecting several MCP servers to extend what Claude Code can reach, know that each one adds a small amount of persistent context cost even when idle, covered in the MCP server setup tutorial.

How do you track Claude Code spend beyond /usage?

/usage covers the basics for one developer on one machine, but it has real limits: its dollar figure is a local estimate, it doesn't see usage from other devices, and it doesn't give an admin a team-wide view. A handful of purpose-built tools fill those gaps depending on what you actually need.

The decision rule is simple: if you're one developer, /usage plus maybe ccusage for richer local history covers you completely, for free. If you're an admin, use whichever built-in dashboard matches your plan first (Team's spend CSV, Enterprise's Analytics API, or the Console dashboard), and only reach for OpenTelemetry or a third-party gateway if you're routed through a cloud provider, where none of Anthropic's own dashboards can see your usage at all.

Is Claude Code cheaper than GitHub Copilot, Cursor, or ChatGPT Codex?

None of the major agentic coding tools price identically, and the entry-tier sticker price tells you less than you'd think, since all four now meter agentic usage separately from simple autocomplete.

GitHub Copilot's entry tier is the cheapest of the four by sticker price, but code completions are unlimited on every Copilot tier while chat, agent mode, code review, and its CLI draw down a monthly AI-credit pool, so a developer who leans heavily on agentic features burns through that $15-in-credits Pro allowance fast and lands on Pro+ or Max regardless. Cursor and Claude Code land close together at the entry and top tiers, $20 versus $17-20 at the bottom, $200 versus $200 at the top, which tracks with both being built around the same core idea: a flat allowance sized to typical usage, with a metered or credit-based option for anyone who exceeds it. ChatGPT's Codex, bundled into ChatGPT plans rather than sold separately, mirrors Claude's own three-tier shape almost exactly, down to matching $100 and $200 Pro tiers offering 5x and 20x the usage of Plus.

It's worth noting that Claude Code's own credit-pool idea for programmatic usage, the one announced May 14 and paused June 15 as covered above, would have made it look structurally more like Copilot's separate credit pool for agentic features. That it got paused says something about how hard "meter the agentic parts separately from the flat-rate parts" actually is to get right without frustrating users who don't distinguish between an interactive session and a script running on their behalf.

The subscription plans exist for one reason: to turn an unpredictable token bill into a flat, poolable one. None of these tools are meaningfully cheaper than the others once you account for how usage-based overage works on each; the real cost driver, for all four, is how much agentic, multi-file, multi-step work you actually run, not which vendor's name is on the invoice.

Does this cost calculus change if you also edit video?

If you're the kind of person who runs Claude Code sessions and also edits in DaVinci Resolve, maybe scripting a batch export, wiring up a Fusion macro through Resolve's Python API, or automating a render queue, the cost mechanics above apply exactly as written; Resolve-adjacent scripting work isn't billed any differently than any other codebase. Where it does matter is scope: a script that walks your entire media pool or reads a large exported timeline XML can rack up input tokens fast, the same "watch your context, not just your task count" discipline covered above, just triggered by footage-shaped files instead of source files.

TryUncle is an AI tutor for DaVinci Resolve on macOS. Ask in plain words and Uncle points at the exact control on your screen, live, on the Edit, Color, and Fusion pages, which solves a different problem than Claude Code does. Claude Code writes and runs scripts against your project; it has no opinion on where a node belongs in your color grade or why a Power Window keeps drifting off a subject's face. TryUncle is a paid macOS app, currently in founder pricing at $29.99/month, cancel anytime, so check TryUncle for the exact current rate rather than trusting a number that might drift by the time you read this. If you're weighing AI tools for the editing side specifically, not the scripting side, that's a separate decision worth its own research, not something this page's token math answers for you.

The verdict

There's no single number for what Claude Code costs, and anyone who gives you one without asking how you sign in is guessing. On a subscription, it's $17 to $20 a month for Pro, or $100 to $200 for Max if Pro's allowance runs out on you, with Claude Code included at no extra line item, and that includes headless and Agent SDK usage today, though Anthropic has already shown it's willing to change that with three weeks of notice. On the API, it's pure token metering with no ceiling, averaging $150 to $250 a month per developer according to Anthropic's own numbers, capable of running far higher for anyone running long, uncleared, Opus-heavy sessions or parallel agent teams. Routed through Bedrock, Vertex AI, or Microsoft Foundry, the per-token math is identical to the direct API, and the only real questions are billing consolidation and how current your feature access stays.

Pick the subscription if you want a bill you can predict before the month starts. Pick the API if you need per-token cost attribution, headless automation, or Enterprise-grade spend controls, and set a workspace spend limit the same day you set it up, not after the first surprising invoice. Uber and Microsoft learned that lesson at a scale most of us never will; the company behind the $500 million month learned it at a scale almost nobody ever will. You don't have to learn it the same way. Check /usage today, set a limit before you need one, and revisit Anthropic's current pricing page before you commit a team's budget to a number this article, or any article, printed months ago.