Claude Code Pricing 2026: Plans, Limits & Alternatives

The complete July 2026 breakdown of what Claude Code actually costs, where the hidden charges live, and which alternative wins for your workload.

Claude Code passed $2.5 billion in run-rate revenue by February 2026, more than doubling in a matter of months, and roughly 4% of all public GitHub commits are now authored by it - Anthropic.

But here's the problem: almost every pricing guide you'll find, including the previous version of this one, describes a product that no longer exists. The model lineup has turned over completely, Opus prices dropped 3x, a new tokenizer quietly raised effective costs by roughly 30%, usage limits have been rewritten three times since March, and half the "alternatives" from a year ago have been renamed, absorbed, or shut down. If you are budgeting for an AI coding agent using 2025 numbers, you are wrong in both directions at once: the sticker prices are lower than you think, and the effective per-task costs are higher.

This guide gives you the full July 2026 picture: every Claude Code plan and what it costs, the model-to-plan mapping nobody else documents cleanly, the complete API rate card with caching and batch mechanics, the usage-limit timeline from August 2025 through the July 13, 2026 expiry, honest break-even math between subscription and API, and a head-to-head against OpenAI Codex, Cursor, GitHub Copilot, Gemini CLI, Kiro, and Devin. Everything is sourced, dated, and current as of July 8, 2026.

Contents

1. The Verdict Table: Every Coding Agent Scored
2. What Claude Code Costs in July 2026: Every Plan
3. The July 2026 Model Lineup and What Your Plan Actually Runs
4. The Full API Rate Card: Caching, Batch, Long Context, and Tools
5. The Hidden 30% Price Increase: The New Tokenizer
6. The Usage-Limit Timeline: August 2025 to July 13, 2026
7. Subscription vs API: The Break-Even Math
8. The Token-Efficiency War: Sticker Price vs Tokens Burned
9. What Your Subscription Buys Beyond the CLI
10. Alternatives Head-to-Head: Codex, Cursor, Copilot, Gemini CLI, Kiro, Devin
11. Enterprise Buying: Seats, CCUs, and Data Residency
12. The Cost-Optimization Playbook for 2026
13. Free and Cheap Ways to Run a Coding Agent
14. Decision Framework: Which Option Fits You

1. The Verdict Table: Every Coding Agent Scored

Before the detail, the summary. We scored the seven major coding-agent options on the four criteria that actually determine what you get for your money in July 2026. Value per dollar (30%) measures what a dollar of spend buys in real work, factoring entry price and token efficiency. Frontier capability (30%) measures raw coding ability on current benchmarks like SWE-bench Pro and Terminal-Bench 2.0. Limits and predictability (20%) measures how transparent and generous the caps and overage mechanics are. Product surface (20%) measures how far the tool reaches beyond a single terminal or editor: web, mobile, autonomous agents, team features.

Each cell contains the score and its justification, because a bare number tells you nothing. The table is sorted by final weighted score, highest first.

Two things jump out of this table. First, Claude Code and Codex tie at 8.4 but get there from opposite directions: Claude Code wins on raw capability and product breadth, Codex wins on price floor and token efficiency. Your workload decides the tiebreak, and we unpack exactly how in section 8. Second, free is now genuinely viable: Gemini CLI's 1,000 daily requests outscore paid mid-tier tools for hobby and light professional use, something that was not true a year ago.

2. What Claude Code Costs in July 2026: Every Plan

Claude Code is not sold as a standalone product. It comes bundled inside Claude subscriptions, and the Free plan does not include it: the feature grid on the official pricing page confirms Claude Code starts at Pro - Claude pricing. That single fact eliminates the most common budgeting mistake: there is no $0 way to run Claude Code against Anthropic's own subscription infrastructure (API pay-as-you-go is the separate path, covered in section 4 and section 7).

The individual lineup has three rungs. Pro costs $20 per month, or $17 per month billed annually, and now bundles far more than the CLI: Claude Code, Claude Cowork, Claude Design, and Claude Science all ship in the one subscription. Max 5x costs $100 per month and multiplies usage roughly five times over Pro. Max 20x costs $200 per month for roughly twenty times Pro usage, and it is the tier where heavy daily agentic work stops hitting walls. For team buyers, Team Standard is $20 per seat per month billed annually ($25 monthly), and Team Premium is $100 per seat annually ($125 monthly) with 5x more usage than Standard. Enterprise runs $20 per seat plus usage billed at API rates, available self-serve or sales-assisted.

Claude subscription pricing (July 2026) - Claude pricing:

Note what changed from the numbers floating around in older guides: Team Standard was widely reported at ~$25 and Premium at ~$150 per seat through 2025. The current official pricing is meaningfully cheaper at the Premium tier ($100 annual versus the old $150), and Premium's value proposition sharpened: it now explicitly carries 5x the usage of Standard, making the seat-mix decision a usage-forecasting exercise rather than a feature checkbox. We cover the enterprise mechanics, including Claude Consumption Units on cloud marketplaces, in section 11.

There is also a quiet arbitrage inside the individual tiers. Annual Pro at $17/month is a 15% discount against monthly, and since the plan's real value is its quota rather than any feature flag, the only reason to stay monthly is genuine uncertainty about whether the tool sticks. Run the numbers the other way and the framing sharpens: $17/month is $204/year for a bundle whose median full-time user consumes roughly $130/month of API-equivalent work (section 7), so the annual plan pays for itself within the first five weeks of normal use. Notably, Anthropic publishes annual pricing only for Pro; the Max tiers stay month-to-month on the official page, which reads as a company that expects its own price structure to keep moving and does not want twelve-month locks on its heaviest users any more than you should want a twelve-month lock on a quota regime that has changed three times since March.

One more structural point that pricing tables hide: quota is shared. Your Claude Code usage, your claude.ai chat usage, and your Cowork sessions all draw from one shared pool on Pro and Max - Anthropic support. When you hit the ceiling you can either wait for the reset or enable extra usage billed at standard API rates from the same account. The practical consequence: a heavy Cowork afternoon eats your evening's Claude Code budget. If you want the deeper Cowork economics, our Claude Cowork pricing and ecosystem guide breaks down how session-based agent work consumes quota differently from interactive coding.

Extra usage deserves its own paragraph, because it changed the shape of the product. Before it existed, hitting a cap meant a hard stop: wait for the window to roll, or upgrade the whole plan. Now the subscription behaves like a flat rate with a metered overflow: you pre-authorize extra usage, and once the shared pool empties, additional work bills at standard API rates against the same account. The strategic effect is that plan choice is no longer a capacity ceiling, only a price break point. A Pro subscriber who overflows about $30 of API-rate usage in a month is paying $50 all-in and should move to Max 5x only when the overflow regularly exceeds the $80 difference between the tiers. A month of honest /status checks plus your overflow line item gives you the only tier decision based on your own data instead of a pricing page's persuasion architecture.

3. The July 2026 Model Lineup and What Your Plan Actually Runs

This is the section that has aged worst in every competing pricing article, so let's state the current reality plainly. As of July 2026, Sonnet 5 is the default model for Free and Pro users, and Opus 4.8 is the default on Max, Team Premium, and Enterprise - model configuration docs. The models that older guides describe as current are gone: Sonnet 4 and Haiku 3.5 are retired, and Opus 4.1 is deprecated, still listed at its old $15/$75 per million tokens as a legacy artifact while every current Opus generation costs a third of that.

The lineup turned over in a rapid three-release sequence during Q2 2026. Opus 4.8 shipped May 28, 2026 at $5/$25 per million tokens, and Anthropic's headline quality claim was about self-review: it is roughly 4x less likely than Opus 4.7 to let flaws in its own code pass unremarked - Anthropic. Fable 5 and Mythos 5 arrived June 9, 2026 at $10/$50, establishing a new frontier tier above Opus; Fable 5 was included free on paid plans for a two-week launch window (June 9-22), after which subscription use requires extra usage credits at API rates, while Mythos 5 remains restricted to approved partners - Anthropic. Then Sonnet 5 landed June 30, 2026 with near-Opus agentic coding at $2/$10 introductory pricing - Anthropic.

Here is the model-to-plan mapping in one table, because no other pricing article we found maps model tier to plan tier cleanly:

Read that table against the March 2026 state of the world and the shift is dramatic: the high end got 3x cheaper (Opus went from $15/$75 to $5/$25 across the 4.5-4.8 generations), while a new $10/$50 tier appeared above it for work that justifies frontier reasoning. For a deeper capability read on each tier, see our Opus 4.8 benchmark guide, the Sonnet 5 cost breakdown, and the Fable 5 and Mythos 5 benchmarks.

The chart makes the generational cliff visible: deprecated Opus 4.1 sits at the top of the price range while its successors, which outperform it, cost a third as much. The practical takeaway for subscribers is version hygiene: Sonnet 5 requires Claude Code v2.1.197 or later and Opus 4.8 requires v2.1.154 or later - model configuration docs. If your CLI is months stale, you are silently running an older, worse default. Run claude update before you evaluate anything about cost or quality.

Where does Fable 5 fit for a subscriber, given that it never draws from the flat quota? Treat it as a per-task purchase. At $10/$50, a substantial agentic task that would consume, say, 3M input and 300K output tokens runs about $45 in extra-usage credits: real money against a $20 plan, trivial against the cost of a senior engineer's afternoon. The rational pattern that emerged after the free June window closed is escalation, not adoption: run everything on your plan's default, and reach for Fable 5 on the specific problems where Opus 4.8 has already failed twice, because a third Opus attempt costs quota and time while a first Fable attempt costs $45 and often ends the loop. Anthropic's own framing of Fable as a Mythos-class model made safe for general use supports reading it as a specialist tier, not a new daily driver - Anthropic.

There is also a fast mode research preview for latency-sensitive work: Opus 4.8 fast mode runs at $10/$50 per MTok, a steep cut from the $30/$150 that Opus 4.7 fast mode charged, and the 4.7 variant is deprecated with removal scheduled July 24, 2026 - Anthropic pricing docs. Fast mode is the exception to the "everything got cheaper" story: you pay Fable-tier rates for Opus-tier output, purely for speed.

The lifecycle cadence is itself a planning input. Three flagship releases in five weeks (May 28, June 9, June 30) is the current tempo, and deprecations move just as fast: Opus 4.7's fast mode went from current to removal in under two months, and Opus 4.1 sits deprecated at triple the price of its successors. For API builders this argues for treating model IDs as configuration, not constants: pin a model per workload, but review the pins monthly, because a stale pin now carries a real price penalty on top of the capability one. Subscription users get migrated automatically, which is convenient but has its own gotcha: a default-model change can shift your quota burn rate overnight through a new tokenizer or different output verbosity, so treat any model-release week as a week to watch /status more closely than usual. The full Q2 release sequence, including Cowork's scheduled tasks in February and the computer-use research preview in March, is documented in Anthropic's release notes - release notes.

4. The Full API Rate Card: Caching, Batch, Long Context, and Tools

If you build on the API directly, or you enable extra usage on a subscription (which bills at these same rates), the per-token price is only the starting point. The July 2026 rate card has four multiplier systems layered on top of base pricing, and using them well is the difference between a painful bill and a trivial one. All figures in this section come from the official pricing documentation - Anthropic pricing docs.

Prompt caching is the biggest lever. A 5-minute cache write costs 1.25x base input, a 1-hour cache write costs 2x, and a cache hit costs 0.1x. On Opus 4.8 that means cache reads at $0.50 per million tokens, a tenth of the $5 base rate. Coding agents are cache-friendly by construction: system prompts, CLAUDE.md files, and repository context repeat on every turn, so real-world agentic sessions routinely serve the majority of input from cache. Batch API stacks on top for asynchronous work: 50% off both input and output on all models, which turns Haiku 4.5 into a $0.50/$2.50 workhorse for bulk transformations.

To see what the multipliers do in combination, price a realistic agentic session. Say a two-hour Claude Code run on Opus 4.8 processes 2 million input tokens, of which 1.6M are repeated context (system prompt, CLAUDE.md, file reads already cached) and 0.4M are fresh, plus 150K output tokens. Naive list-price math says 2M x $5 plus 0.15M x $25, which is $13.75. With caching, the 1.6M repeated tokens bill at the $0.50 cache-read rate ($0.80), the 0.4M fresh tokens carry the 1.25x write premium ($2.50), and output is unchanged ($3.75): the session lands near $7, roughly half the naive figure. The same structure applies to every agent you build. The more stable your context, the closer your effective input rate drifts toward the 0.1x cache floor, which is why cost comparisons between tools that cache well and tools that do not are meaningless at list price, and why section 12 treats caching discipline as the first optimization rather than an advanced one.

The long-context story has flipped from surcharge to standard. Older articles warned about a Sonnet surcharge of $6/$22.50 above 200K tokens. That structure is gone for current models: Fable 5, Mythos 5, Opus 4.6 through 4.8, Sonnet 5, and Sonnet 4.6 all include the full 1M-token context window at standard per-token pricing. You still pay for the tokens you send, and a full million-token context is real money on any model, but there is no punitive rate tier anymore.

Tool and agent pricing (July 2026):

Two of those rows deserve emphasis because they are new since the last generation of pricing guides. First, code execution moved from 1,500 to 1,550 free container-hours monthly, and the free-when-paired rule is a genuine loophole: an agent that runs code as part of a web-search-driven task pays nothing for the sandbox. Second, Claude Managed Agents introduced session-hour billing at $0.08, a different meter from anything Anthropic sold before; our Managed Agents guide walks through when session-hour economics beat raw API calls. If you are building your own agents on the SDK rather than consuming Anthropic's packaged ones, the Claude Agent SDK deep dive covers the token flow end to end.

For a broader cross-provider view of how these rates compare, our AI model benchmarks and pricing snapshot tracks the whole market, though note it predates the Sonnet 5 launch. The rate card above is what matters for budgeting Claude specifically, and every optimization in section 12 is built from these four multiplier systems.

5. The Hidden 30% Price Increase: The New Tokenizer

Here is the fact that invalidates most per-token cost comparisons you will read this year: Opus 4.7 and later, Sonnet 5, Fable 5, and Mythos 5 use a new tokenizer that produces approximately 30% more tokens for the same text - Anthropic pricing docs. The list price per million tokens is real, but the number of tokens in your million changed. A codebase that tokenized to 100K tokens under the old scheme tokenizes to roughly 130K under the new one, and you pay for 130K.

Run the worked example. Suppose a refactoring task involves 400K words of code and context flowing through the model as input and 40K words generated as output. Under the old tokenizer, call that roughly 520K input tokens and 52K output tokens. On Opus 4.8 at $5/$25, that is $2.60 input + $1.30 output = $3.90. Under the new tokenizer, the same text becomes roughly 676K input and 68K output tokens: $3.38 + $1.70 = $5.08. Same task, same model list price, ~30% higher effective cost. Now compare against deprecated Opus 4.1 at $15/$75 with the old tokenizer: the same task cost $11.70 + $3.90 = $15.60. So the honest generational comparison is $15.60 down to $5.08: a 3.1x real-cost improvement, not the 3x sticker cut and not the naive "3x cheaper AND same tokens" that a list-price table implies.

The tokenizer shift matters in three places. On the API, it inflates every bill relative to what a spreadsheet built on list prices predicts, so pad API budget models by 30% for current-generation models. On subscriptions, it consumes your quota faster: the same 5-hour window of work burns more tokens, which is part of why Anthropic's limit increases (section 6) were necessary to keep the subjective experience stable. And in competitor comparisons, it means "Claude charges $2/MTok and competitor X charges $2.50/MTok" is not a like-for-like statement unless you normalize for tokens-per-task, which is exactly the fight we cover in section 8.

There is no way to opt out of the new tokenizer on current models, and mostly you should not want to: the current generation is better and cheaper even after the 30% adjustment, as the worked example shows. The point is calibration. Every cost figure in this guide that involves current-generation models already lives in the new-tokenizer world; when you see older benchmarks of "tokens consumed per task" from 2025, mentally inflate them before comparing.

For teams that track internal metrics, the practical move is to re-baseline. Any dashboard built in 2025 that reports tokens per pull request or cost per completed task now mixes two tokenizer regimes, and quarter-over-quarter comparisons will show a mysterious 30% regression that no engineering change explains. Recompute historical baselines on the new tokenizer where you can, or at minimum annotate the cutover on every chart. And when you evaluate vendor claims, ask which tokenizer generation the numbers come from: a benchmark that says a task "costs 400K tokens on Claude" means something different in March than in July, and that difference is exactly the margin by which many build-versus-buy decisions get made.

6. The Usage-Limit Timeline: August 2025 to July 13, 2026

Usage limits are the single most-searched Claude Code pricing topic, and the story has moved a long way past "weekly limits introduced August 2025," which is where most guides still end. Here is the full sequence. In August 2025, Anthropic added weekly caps on top of the existing 5-hour rolling windows, after a period when a small number of users ran Claude Code around the clock. In March 2026, it ran an off-peak experiment that doubled limits during low-traffic hours, testing whether capacity-aware quotas could relieve pressure. On May 6, 2026, the experiment graduated: the 5-hour rolling caps were permanently doubled for Pro, Max, Team, and Enterprise. And on May 13, 2026, Anthropic raised weekly limits by 50%, explicitly time-boxed from May 13 through July 13, 2026 - Pasquale Pillitteri.

That last date matters right now: as of this writing (July 8, 2026), the weekly boost expires in five days. Post-boost, a Pro subscriber has been getting roughly 60 Sonnet-hours per week; if the boost lapses without renewal, expect roughly a third less weekly headroom, back to the May 6 baseline. The old "40-80 hours of Sonnet 4 per week" framing you will still find in search results references a retired model and a superseded quota regime; discard it entirely.

Three mechanics govern how these limits feel in practice. First, as covered in section 2, the quota is one shared pool across Claude Code, claude.ai, and Cowork, so limit math is household math, not per-tool math. Second, when you hit a cap you have two options: wait for the reset (5-hour windows roll continuously; weekly resets are weekly) or enable extra usage billed at standard API rates from the same account - Anthropic support. Third, you can always check where you stand: the /status command inside Claude Code shows your remaining allocation, and making /status a habit is the cheapest usage-management tool that exists.

What should you assume happens after July 13? Anthropic has not committed publicly either way, which is itself information: a permanent increase would have been announced as one, the way the May 6 doubling was. The base case is reversion to the May 6 baseline, with the door open to another competitive boost whenever OpenAI moves next; the pattern of the past four months is that limits move as marketing, on dates chosen by the competition. If your team sized itself to boosted limits (say, agent teams tuned to burn the full weekly pool), rehearse the reversion now: cut team sizes or shift the overflow to extra usage at API rates for a week and measure the delta. Better to learn it costs $40/month in a controlled experiment than to discover it as a stalled sprint on July 14.

It is also worth translating the two leading vendors' cap systems into the same units, because they are built on different philosophies. Anthropic meters hours of model work through a shared token pool; OpenAI meters messages per rolling window, 15-80 GPT-5.5 messages per 5 hours on Plus and up to 300-1,600 on Pro 20x - OpenAI. Message metering is easier to reason about for interactive use but tends to punish long agentic runs, where one task fans out into many counted turns; token-pool metering does the reverse, punishing chatty interactive use while letting a well-scoped autonomous session run deep. Match the meter to your workload shape and half of the "whose limits are more generous" arguments dissolve: they are generous along different axes.

Why did Anthropic loosen limits three times in four months? Competitive pressure, primarily. The May 13 boost was widely read as a direct response to OpenAI's Codex push, whose token efficiency advantage (section 8) meant Codex users simply hit walls less often at the same sticker price - Pasquale Pillitteri. The strategic takeaway for buyers: limits are currently a competitive battleground, which means they are more likely to loosen than tighten through 2026, but time-boxed boosts like the May 13 one should never be baked into your capacity planning. Budget on the permanent baseline, treat boosts as free upside.

7. Subscription vs API: The Break-Even Math

The question underneath every Claude Code pricing search is really this one: subscription or pay-as-you-go? The 2026 rate changes moved the break-even points, so let's redo the math with current numbers rather than folklore.

Start with what real usage looks like. Analysis of actual developer spend found the median Claude Code developer consumes about $6 per day in API-equivalent value, with 90% staying under $12 per day - Duet. A $6/day median over ~22 working days is roughly $130/month of API-equivalent usage, which already makes the $100 Max 5x plan a modest win for the median full-time user, and makes the $20 Pro plan spectacular value for anyone whose usage fits inside its limits. At the heavy tail the gap becomes absurd: one documented case ran $15,000 in API charges over 8 months for usage that would have cost about $800 on Max across the same period - Duet. That is the "~18x cheaper" claim you see quoted, and with the caveat that it describes a tail-case power user, the direction is right: at heavy usage, subscriptions crush the API on price.

So when does the API actually win? Three scenarios, all real. Intermittent use: if you code with an agent a few days a month, pay-as-you-go on Sonnet 5 at intro pricing ($2/$10 through August 31, 2026) can land under $20/month, beating Pro. Cheap-model pipelines: bulk work on Haiku 4.5 ($1/$5), especially with Batch API at 50% off and cache hits at 0.1x, produces per-task costs a subscription cannot express; a nightly batch job transforming thousands of files has no business running on a seat-based plan. Production automation: anything that runs headless, unattended, or at scale belongs on the API (or on Managed Agents at $0.08/session-hour) because subscription limits exist precisely to prevent that pattern.

Make it concrete with three profiles. The weekend builder ships a side project two weekends a month, perhaps eight real agent-days a year. On pay-as-you-go with Sonnet 5 intro pricing, that is plausibly $8-15 in the months they build and $0 in the months they do not, while Pro costs $20 every month regardless: the API wins. The full-time engineer runs Claude Code most working days at the $6/day median, roughly $130/month API-equivalent: Pro at $20 captures all of it if the caps hold, and Max 5x at $100 still beats the meter if they do not, so the subscription wins decisively. The platform team runs agents in CI on every pull request, say 400 runs a month at 300K tokens each: that is machine work, excluded from subscription terms by design, and it belongs on Haiku 4.5 with batch and caching, where the entire fleet can cost less than a single Max seat. Same product, three different rational meters.

The clean decision rule: humans on subscriptions, machines on the API. A human developer's usage is bursty and capped by their attention, which is what subscription pricing is designed around. Automated pipelines are limited only by budget, which is what per-token pricing is designed around. The hybrid pattern that sophisticated teams have converged on is a Max plan per developer plus an API key for CI, batch, and production agents, with extra usage on the subscription as the overflow valve rather than the primary meter. If you are new to Claude Code entirely, our beginner's guide covers setup before any of this math matters, and the June 2026 cost snapshot shows how these numbers looked one model generation ago.

8. The Token-Efficiency War: Sticker Price vs Tokens Burned

Every comparison table in this space, including ours in section 1, prices tools by monthly subscription. But the metric that actually determines value is tokens burned per completed task, and on that metric the market is not close to uniform. Independent testing found Codex consumed 3-4x fewer tokens than Claude Code for equivalent tasks; in one documented comparison, building a Figma plugin took Codex about 1.5 million tokens and Claude Code about 6.2 million - Pasquale Pillitteri.

Why does the gap exist? Partly philosophy: Claude Code's agentic style is exploratory, reading widely through a repository, re-verifying its own work, and (post-Opus 4.8) explicitly self-reviewing for flaws, which is token-hungry by design. Partly the tokenizer effect from section 5: current Claude models produce ~30% more tokens for identical text, so even identical behavior would read as less efficient in raw token counts. And partly optimization targets: OpenAI has visibly tuned Codex for economy, because economy is the axis where it can win against a capability leader.

The consequences ripple through every pricing decision in this guide. On subscriptions, token efficiency determines how far your quota stretches: a Codex Plus user at $20/month hits limits less often than a Claude Pro user at $20/month doing the same work, even if the plans look symmetric on paper. That asymmetry is precisely why Anthropic's May limit increases happened, and why they were read as defensive - Pasquale Pillitteri. On the API, efficiency multiplies against per-token rates: Sonnet 5 at $2/$10 intro pricing versus GPT-5.5's rates is not a two-line comparison, it is a four-variable one (rate x tokens-per-task, per provider).

Put numbers on the four-variable math to see how it flips. Take the documented Figma-plugin case: Claude Code at 6.2M tokens, Codex at 1.5M. Assume a typical 80/20 input/output split. On Sonnet 5 intro rates, the Claude run prices out near $22 (4.96M input at $2 plus 1.24M output at $10), while the Codex run at GPT-5.5's credit rates lands in the low single digits: efficiency wins by a mile. Now rerun it as a hard task where the efficient tool needs three attempts plus a human half-hour of cleanup, and the totals invert before you even price the human time. Neither vendor's marketing survives contact with this arithmetic, which is the point: cost per completed task, measured on your own repository, is the only number that generalizes.

But efficiency is not quality, and the counterweight is real: Opus 4.8 leads SWE-bench Pro at 69.2% versus 58.6% for GPT-5.5, a gap of more than ten points on the benchmark that best resembles real enterprise codebases, while GPT-5.5 holds the edge on Terminal-Bench 2.0 (82.7% vs 74.6%) and the two are statistically tied on the older SWE-bench Verified (88.7% vs 88.6%) - Morph. A tool that burns 4x the tokens but succeeds on the first attempt can be cheaper than an efficient tool that needs three tries. The honest synthesis: for hard, long-horizon tasks in messy codebases, Claude Code's capability premium tends to pay for its token appetite; for high-volume routine work, Codex's efficiency compounds into real savings. Measure your own mix before believing anyone's table, including this one.

9. What Your Subscription Buys Beyond the CLI

A 2025-vintage pricing guide treats Claude Code as a terminal program and prices it accordingly. In July 2026 the same subscription buys a materially larger product surface, which changes what "is $20/month worth it" even means. Understanding the full bundle is essential for comparing against alternatives that remain single-surface tools.

The headline expansion is Claude Cowork, Anthropic's agentic workspace for non-coding work. Cowork launched desktop-only in January 2026, and on July 7, 2026 it expanded to web and mobile, rolling out to Max subscribers first, with sessions that run remotely and keep working with your laptop closed - TechCrunch. The same TechCrunch analysis of 1.2 million Claude sessions found business-process operations at 33.4% of usage versus 8.7% for software development: the "coding agent" subscription is now majority-used for non-coding work across the user base. Alongside Cowork, Pro-and-up plans bundle Claude Design and Claude Science, and Claude Code itself now runs on web and desktop, not just the terminal - Claude pricing.

For most subscribers, the bundle's economics reduce to one question: does anything besides the CLI replace paid work you currently do elsewhere? A design tool seat, a research assistant subscription, an automation platform's starter tier: each one the bundle displaces adds $10-30/month of effective value to the same $20 plan. We track the individual surfaces separately, in our Cowork guide across desktop, web, and mobile and our Claude Design deep dive, but the pricing takeaway is that Anthropic is deliberately making the $20 comparison unfair: no single-surface competitor can match a bundle, so they compete on the excellence of their single surface instead.

The July 7 expansion also changes the quota calculus in a subtle way. Remote Cowork sessions keep working with the laptop closed - TechCrunch, which means quota consumption is no longer bounded by the hours you sit at a desk. An agent you brief at 6pm can spend your shared pool all evening, and on Pro that arithmetic surprises people: the morning's Claude Code session inherits whatever the overnight run left behind. Max's larger multiples exist for exactly this always-on pattern, and the rollout order (Max first) says Anthropic knows it. Budget remote sessions the way you budget cloud instances, not the way you budget an app you open and close.

For engineering teams specifically, the most consequential addition is agent teams, an experimental Claude Code capability enabled via the CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS flag: multiple coordinated Claude Code instances share a task list and message each other, parallelizing work across a codebase - agent teams docs. The pricing fine print is the part to internalize: each teammate is a separate instance with its own context window, so token usage scales roughly linearly with team size. A five-agent team burns quota about five times as fast as a solo session. On a Max 20x plan that is a powerful trade; on Pro it is a fast route to the weekly cap. Treat team size as a literal budget dial.

The diagram is the budgeting model to keep in your head: every surface drains one pool, and the pool's overflow valve is API-rate billing. This is also where comparisons with alternatives get slippery. Cursor's $20 buys an IDE. Copilot's $10 buys IDE assistance plus credits. Claude's $20 buys a coding agent plus a general-purpose agentic workspace plus design and science tools, sharing one quota. Whether that bundle is worth more depends entirely on whether you use the non-coding surfaces; a developer who lives only in the terminal is paying for breadth they never touch, which is a genuine argument for Codex or Cursor at the same price point. For teams who want agents running whole business workflows rather than just code, that same logic extends past Anthropic's bundle entirely: platforms like O-mega provision an AI agent workforce that operates browsers, tools, and processes end to end, a different altitude of automation than a per-developer coding subscription.

10. Alternatives Head-to-Head: Codex, Cursor, Copilot, Gemini CLI, Kiro, Devin

The alternatives landscape did not just reprice since the last version of this article; it reorganized. Windsurf no longer exists as a standalone product: windsurf.com/pricing permanently redirects to devin.ai, where the editor lives on as Devin Desktop under Cognition. CodeWhisperer is dead as a product name; AWS's coding agent is now Kiro. And Bard-era Google tooling is irrelevant; the free competitor that matters is Gemini CLI. Here is the full July 2026 head-to-head, followed by profiles of each.

OpenAI Codex is the closest competitor and the sharpest price attack. Codex is bundled into ChatGPT tiers rather than sold separately: Free $0, Go $8/month, Plus $20/month, Pro from $100/month, Business $20/user/month. Usage runs on a 5-hour rolling window: roughly 15-80 GPT-5.5 messages on Plus, 75-400 on Pro 5x, and 300-1,600 on Pro 20x. Codex moved to token-based credit billing on April 2, 2026 for overages (GPT-5.5 at 125 credits per million input tokens, 750 per million output), with typical tasks consuming 5-45 credits, and added the Pro 5x tier at $100 on April 9 - OpenAI. The current agent model is GPT-5.3-Codex alongside GPT-5.5 (shipped April 23, 2026). The $8 Go tier is the cheapest paid on-ramp to a frontier coding agent on the market, full stop. Combined with the token-efficiency edge from section 8, Codex is the value play; it concedes the capability high ground on SWE-bench Pro. Our GPT-5.5 guide covers the model side in depth.

Cursor remains the strongest IDE-native option. The July 2026 lineup is Hobby free, Pro $20, Pro+ $60, Ultra $200 (about 20x Pro usage), Teams $40/user, Enterprise custom - Cursor. Two mechanics distinguish it: paid plans carry a dollar-denominated credit pool spent on frontier models at API-like rates (transparent, but fast-burning on expensive models), and Auto mode is unlimited, routing to Cursor's choice of model without touching credits. Cursor is an editor experience first and an agent second; if your workflow is fundamentally IDE-centric, it competes on feel rather than on benchmark ceilings.

GitHub Copilot went through the biggest billing change of the year: on June 1, 2026 it moved to usage-based billing with GitHub AI Credits, replacing the old premium-request system. Plans are Pro $10, Pro+ $39, Business $19/user, Enterprise $39/user, plus a new Max tier at $100, each with monthly credit allotments; Business and Enterprise get $30 and $70 promotional bonus credits through August 2026, code completions and Next Edit stay unlimited, and the old fallback models were removed - GitHub. Copilot's moat is not model quality but placement: it lives where the PRs, issues, and repos already are.

Gemini CLI is the free-tier champion: 1,000 model requests per day and 60 per minute at no cost with a personal Google account, rising to 1,500/day on paid Code Assist Standard and 2,000/day on Enterprise - Google. The model generation behind it is Gemini 3 (Gemini 3 Pro API pricing runs about $1.25/$10 per MTok), capable but trailing roughly 15 points behind Opus 4.8 on SWE-bench Pro - Morph. For context on Google's lineup, see our Gemini 3.1 Pro guide. As a $0 daily driver or an overflow tool when other quotas run dry, it has no peer.

Kiro and Devin round out the field. Kiro, AWS's spec-driven agent IDE, prices in credit packs: Free 50 credits/month, Pro $20 (1,000 credits), Pro+ $40 (2,000), Pro Max $100 (5,000), Power $200 (10,000), with overage at $0.04/credit and no rollover of unused credits - Kiro. Devin absorbed Windsurf and now spans an autonomous agent plus Devin Desktop: Free $0, Pro $20/month, Max $200/month, Teams $80/month plus $40 per developer seat - Devin. Both are credible in their niches (AWS-centric teams for Kiro, delegated autonomous tasks for Devin), and both are harder to cost-predict than the credit-transparent leaders.

The graveyard deserves more than a passing mention, because stale tool lists actively mislead budgets. CodeWhisperer, AWS's first-generation coding assistant, no longer exists as a product name; its successor Kiro is a different product with a different pricing philosophy, credits instead of seats. Windsurf, which a year ago was a top-five standalone AI editor, was absorbed into Cognition: windsurf.com/pricing now returns a permanent redirect to devin.ai/pricing, and the editor survives as Devin Desktop - Devin. Bard is long gone as a Google brand, replaced by the Gemini family and, for terminal work specifically, Gemini CLI. If a comparison article you are reading prices any of those three as living products, close the tab: every number near them predates the current market.

The chart explains why "which model is best" arguments talk past each other: on SWE-bench Verified, the two leaders sit a tenth of a point apart and the benchmark is effectively saturated; on SWE-bench Pro, which uses harder, more realistic enterprise tasks, Opus 4.8's 69.2% opens a 10.6-point lead over GPT-5.5, with Gemini 3.1 Pro trailing roughly 15 points behind Opus on the same benchmark - Morph. Pick your benchmark and you pick your winner, which is why section 8's tokens-per-task lens matters as much as either.

One category note to close the section: all of these are developer tools that assist or automate coding. If the job you actually want done is broader (research, operations, outreach, whole workflows executed by autonomous agents in the cloud), that is a different product category, and it is where an agent-workforce platform like O-mega sits as the alternative: you brief agents on outcomes rather than pair-program with a model.

11. Enterprise Buying: Seats, CCUs, and Data Residency

Enterprise Claude buying in 2026 is a three-lever negotiation: seat mix, consumption mechanics, and compliance multipliers. Getting the levers right matters more than the list prices, because the deltas compound across hundreds of seats.

The seat mix decision is Standard versus Premium. At $20 versus $100 per seat annually, Premium costs 5x and delivers 5x the usage of Standard - Claude pricing. The naive read is "same price per unit of usage, so who cares," but the operational read is different: a Premium seat is for engineers whose Claude Code usage is a daily primary tool (where hitting Standard's caps would interrupt real work), while Standard seats fit occasional users, reviewers, and non-engineering staff who mostly touch Cowork or chat. Most organizations that have published their experience land at a 20-30% Premium mix. Above Team sits Enterprise at $20 per seat plus usage billed at API rates, self-serve or sales-assisted, which converts the plan from a quota bundle into a metered utility with a seat-license floor: better for organizations that want chargeback-able consumption data per team.

Price a concrete organization to see the levers interact. Take 100 engineering seats with a 25% Premium mix: 75 Standard seats at $20 and 25 Premium at $100 is $4,000/month, or $48K/year on annual billing. The same headcount all-Premium is $10,000/month, all-Standard is $2,000/month with predictable cap pain for the heaviest quartile: the mix is a $96K/year swing on identical headcount, which is why usage forecasting beats feature-grid reading. Now add the compliance multiplier: if the same organization commits $500K/year of API usage for its automation and turns on US data residency, the 1.1x multiplier adds $50K/year, roughly the cost of another 25 Premium seats. None of these numbers is exotic. They are all first-order consequences of the published rate card, which is exactly why buyers who model them before the negotiation do better than the ones who discover them on the first invoice.

Procurement routing has its own economics. Buying through AWS Marketplace or Microsoft Foundry bills in Claude Consumption Units at $0.01 per CCU - Anthropic pricing docs, which lets Claude spend draw down existing cloud committed-spend agreements: often the difference between a new budget line (slow) and an existing one (fast). Compliance adds the last multiplier: US-only data residency (inference_geo: us) costs a 1.1x multiplier on all token pricing for Opus 4.6/Sonnet 4.6 and later - Anthropic pricing docs. Ten percent for jurisdictional certainty is cheap against the alternative of a failed vendor review, but it belongs in the model: a $1M/year API commitment becomes $1.1M with residency on.

The vendor-viability box, for the committee that asks: Anthropic raised a $30 billion Series G on February 12, 2026 at a $380 billion post-money valuation, reporting a ~$14 billion revenue run rate; Claude Code alone exceeds $2.5 billion run-rate revenue, business subscriptions quadrupled, enterprise is over half of Claude Code revenue, and weekly active users doubled since January 1 - Anthropic. Whatever else is uncertain in this market, counterparty risk on a five-figure annual commitment is not the thing to lose sleep over. The genuinely open enterprise questions are the ones this guide has already priced: tokenizer-inflated consumption forecasts (section 5), the post-July-13 limit baseline (section 6), and agent-team multipliers (section 9).

12. The Cost-Optimization Playbook for 2026

Every mechanism in this section follows from the rate card in section 4; none of it is folklore. Applied together, these routinely cut effective Claude spend by half or more, whether you meter in dollars (API) or in quota (subscription).

Start with the two structural discounts. Prompt caching is the highest-leverage single change for agentic work: cache reads at 0.1x mean a stable system prompt and repo context cost a tenth on every turn after the first, and choosing the 1-hour cache write (2x) over the 5-minute write (1.25x) pays for itself whenever a session lasts longer than a coffee break. Batch API at 50% off everything is the second: any workload that can tolerate async (test generation, migration sweeps, doc generation, evaluation runs) should never run at interactive rates.

A note on choosing between the two cache durations, because it is the one caching decision teams reliably get wrong. The 5-minute write at 1.25x is nearly free insurance and the right default for interactive work with a steady turn cadence. The 1-hour write at 2x costs 60% more up front and pays off only when context is genuinely reused across a long session or across multiple runs inside the hour: agent fleets sharing a system prompt, evaluation harnesses, batch pipelines with common preambles. The crossover comes early, since a handful of reads at the 0.1x rate repays either premium, but the direction of the mistake matters: over-writing throwaway context to the 1-hour tier wastes a little money, while under-caching stable context wastes ten times more. When in doubt, cache.

Then the model-selection plays, in rough order of impact:

• Ride the Sonnet 5 intro window: $2/$10 through August 31, 2026, then $3/$15. Every heavy Sonnet workload run before September gets a built-in 33% discount - Anthropic
• Switch models mid-session: default to Sonnet 5, escalate to Opus 4.8 only for the gnarly architecture or debugging turns, drop to Haiku 4.5 for mechanical edits
• Pair code execution with web search or fetch: the sandbox becomes entirely free, versus burning the 1,550 free hours or paying $0.05/hr - Anthropic pricing docs
• Watch /status and effort levels: check remaining quota before big runs, and match reasoning effort to task difficulty instead of running maximum effort by default
• Size agent teams deliberately: each experimental teammate multiplies token burn roughly linearly (section 9), so parallelism is a budget decision, not a free speedup

The common thread in that list is that defaults are expensive: default model, default effort, default single-shot (non-batch) execution, and default always-on caching-off all leave money on the table. The teams that report the lowest per-task costs treat model routing as an engineering concern, the same way they treat database indexes.

One warning against over-optimizing: the failure mode of aggressive cost tuning is spending Opus-grade engineer time babysitting Haiku-grade output. The $6/day median from section 7 is the anchor; if your optimization program is saving $3/day per developer and costing 20 minutes of their attention, it is destroying value. Optimize the machine-scale spend (API pipelines, batch jobs, agent fleets) ruthlessly, and let humans on subscriptions mostly just work. For hands-on patterns, our guides to building a live app with Claude Code and building and deploying websites with Claude Code show these tactics inside real projects.

13. Free and Cheap Ways to Run a Coding Agent

No competing pricing article consolidates the bottom of the market, so here it is: the legitimate ways to run a real coding agent for free or nearly free in July 2026, and what each ceiling looks like. This matters for students, side-project builders, and anyone evaluating tools before committing a team.

The standout is Gemini CLI: 1,000 model requests per day, 60 per minute, free with any personal Google account - Google. A thousand requests is a full day of iterative agent work, not a teaser, and for many hobbyists it simply is their coding agent. The catch is the capability gap on hard tasks (section 10), but "free and 85% as good" is a strong position. ChatGPT Go at $8/month is the cheapest paid frontier access: Codex included, real GPT-5.5 messages, at less than half of everyone else's entry price - OpenAI. Kiro's free tier gives 50 credits monthly (a genuine trial rather than a working allowance), Cursor Hobby and Devin Free similarly serve as extended evaluations, and API trial credits (typically ~$5 across providers) let you benchmark models on your own code before spending anything.

Two Claude-specific programs round out the picture. Claude for Open Source grants qualifying maintainers 6 months of Max 20x, a $1,200 value aimed at the people whose repos train and test everyone's models. And on any paid Claude plan, the Sonnet 5 intro window (section 12) is functionally a discount program with an August 31 expiry. If your budget is literally zero, the honest stack is Gemini CLI as the daily driver plus free-tier trials of the paid leaders for the tasks Gemini fumbles; if your budget is one coffee, ChatGPT Go's $8 buys the most agent per dollar on the market.

One evaluation tactic stretches every free tier further: benchmark with a fixed task portfolio instead of ad-hoc prompting. Pick five real tasks from your own backlog (a bug fix, a refactor, a greenfield feature, a test-writing job, a documentation pass), run the identical five on each candidate's free tier, and score completion, cleanup time, and where each tool gave up. Five tasks fit comfortably inside Kiro's 50 credits, a single Gemini CLI afternoon, and a Cursor Hobby trial, and the resulting comparison beats any published benchmark because it is weighted by your codebase, your conventions, and your definition of done. The free tiers exist to sell subscriptions; used deliberately, they are also the cheapest procurement research available.

What the free tier does not buy, anywhere, is scale or autonomy: every $0 option is rate-limited by design, and every serious autonomous workload graduates to metered billing on some axis (tokens, credits, session-hours, or seats). The bottom of the market is for learning and evaluating. The moment an agent starts doing work you would otherwise pay a person for, you are in the economics of sections 7 through 11.

14. Decision Framework: Which Option Fits You

Strip away the tables and the decision compresses to a handful of forks. If you are an individual developer using an agent daily, Claude Pro at $20 (or $17 annual) is the default answer, with an upgrade to Max 5x the moment limits interrupt you more than once a week; the capability lead on SWE-bench Pro is real, and the bundle (Cowork, web/mobile agents, Design, Science) keeps widening. If price floor beats capability ceiling for you, Codex via ChatGPT Go at $8 or Plus at $20 delivers the market's best token efficiency, and Cursor at $20 is the pick if you want the agent living inside an IDE. If your usage is bursty or pipeline-shaped, skip subscriptions: Sonnet 5 intro pricing and Haiku 4.5 with caching and batch discounts make the API the rational meter. If you are spending nothing, Gemini CLI's 1,000 free daily requests are the answer until they aren't.

Whatever you choose, put a review date on the decision. Every load-bearing number in this guide has a shelf life measured in weeks: intro pricing expires August 31, the limit boost expires July 13, Copilot's bonus credits lapse in August, and the Q2 release tempo suggests the model lineup will turn over again before year end. A pricing decision made in July and never revisited will be quietly wrong by October, not because you chose badly but because the market repriced underneath you. The teams that handle this well treat coding-agent spend like any other cloud line item: a quarterly re-quote against current price lists, a standing usage report per developer, and a willingness to switch meters (subscription to API, or the reverse) when the workload shape changes.

Three time-sensitive facts to act on this quarter. The weekly-limit boost expires July 13, 2026: if you are near your caps today, you will be over them next week, so re-evaluate your tier now rather than mid-sprint. The Sonnet 5 intro pricing ends August 31, 2026: front-load heavy API workloads. And the Copilot promotional credits for Business and Enterprise run out in August: if you are benchmarking Copilot's new credit economics, do it while the bonus skews cheap.

The bigger arc is worth naming as you budget. Coding agents stopped being a developer-tools line item and became general work infrastructure: a third of Claude sessions are business-process operations, enterprise is over half of Claude Code's revenue, and the agent surface now spans terminal, web, mobile, and autonomous background sessions. Pricing models are racing to keep up with that reality (shared pools, session-hours, consumption units), and the buyers who win are the ones who model work completed per dollar, not tokens per dollar or seats per dollar. That is the number every section of this guide has been steering you toward.

This guide was researched and written by Yuma Heymans (@yumahey), founder and CEO of O-mega and co-founder of HeroHunt.ai, who spends an unreasonable share of his week watching coding agents burn tokens so you can budget for it precisely.

This guide reflects pricing and plans as of July 8, 2026. AI pricing changes monthly (sometimes weekly): verify current rates on the official pricing pages linked throughout before committing budget.