Quick answer: sign in at console.anthropic.com (it now redirects to the same developer console as platform.claude.com), add a payment method under Settings → Billing, click API Keys → Create Key, name it, and copy it immediately — Anthropic shows the key exactly once. Keys start with sk-ant-. The whole process takes about five minutes.
Below is the full walkthrough, where to put the key so it doesn’t leak, the newer no-static-key option most tutorials haven’t caught up with, and the errors that account for nearly every failed first request.
What you need before you start
An email address (or Google / SSO login)
A payment method — your key will not work until billing is set up, even though you can create one
Five minutes
One distinction that confuses almost everyone: a Claude.ai subscription is not API access. Claude Pro, Max, and Team plans cover the Claude apps (web, desktop, mobile). The API is billed separately, by usage, through the developer console. You can have either one without the other — see our complete Claude pricing guide for how the two systems differ.
Step 1: Create your account
Go to console.anthropic.com — Anthropic’s developer console. (Both console.anthropic.com and platform.claude.com land in the same place in 2026; older tutorials treat them as different sites.) Sign up with email, Google, or SSO, and answer the brief onboarding questions about whether you’re an individual or an organization. For a tour of everything inside the console, see our Anthropic Console guide.
Step 2: Add billing
In the console, open Settings → Billing and add a credit card (self-serve accounts typically purchase prepaid usage credits). Skipping this step is the #1 reason a brand-new key returns errors — the key exists, but requests are rejected until the account can be billed.
Step 3: Create the key
Click API Keys in the left sidebar (direct link: platform.claude.com/settings/keys), then Create Key. Give it a descriptive name like my-app-dev — future you will thank present you when it’s time to rotate or revoke. If your organization uses multiple workspaces, note that keys are scoped to a workspace: the key only sees resources in the workspace it was created in.
Step 4: Copy it immediately
The key is displayed exactly once. It starts with sk-ant- followed by a long string. Copy it straight into a password manager, a .env file, or your secrets manager. If you lose it, there is no way to view it again — you revoke it and create a new one (takes a minute, harms nothing).
Where to put the key (and where never to put it)
Set it as an environment variable named ANTHROPIC_API_KEY — every official Anthropic SDK reads that variable automatically, so your code never contains the key:
macOS / Linux:export ANTHROPIC_API_KEY=sk-ant-...
Windows (PowerShell):setx ANTHROPIC_API_KEY "sk-ant-..."
Python:client = anthropic.Anthropic() — no key argument needed
TypeScript:const client = new Anthropic() — same
Never hardcode the key in source files, never commit it to a repository, and never paste it into a system prompt or chat message. Leaked Anthropic keys get scraped and drained like any other credential.
The 2026 no-key option: OAuth login
Newer than most guides: Anthropic’s CLI can authenticate without any static key. Run ant auth login and a browser window authorizes a short-lived OAuth profile on your machine — the SDKs and Claude Code pick it up automatically, and there is no permanent secret to leak or rotate. For CI servers and production workloads, Workload Identity Federation serves the same purpose. If you’re setting up a personal development machine in 2026, this is arguably the better default; create a static key when you need one for a deployed service.
Test your key
One request confirms everything works (Haiku keeps the test nearly free):
A JSON response with a content array means you’re live.
Troubleshooting the four common errors
401 authentication_error — the key is missing, mistyped, or revoked. Subtle 2026 variant: if both ANTHROPIC_API_KEY and ANTHROPIC_AUTH_TOKEN are set, the SDK sends both and the API rejects the request — unset one.
403 permission_error — the key works but lacks access to that model or feature; check your key’s workspace and your organization’s model access.
429 rate_limit_error — you’re sending faster than your usage tier allows. The response includes a retry-after header; official SDKs retry automatically. For tier details and fixes, see our Claude rate limits guide.
Key created but every request fails — almost always billing not completed (Step 2).
FAQ
Is the Anthropic API free? No — it’s usage-priced per million tokens with no permanent free tier (current rates in our Claude pricing guide, including the June 2026 lineup with Fable 5).
Where do I find my existing API key? You can’t — Anthropic shows keys only at creation. Revoke the old one and create a replacement.
Does my Claude Pro or Max subscription include an API key? No. App subscriptions and API billing are separate systems; an API account starts at $0 and bills per token used.
What models can a new key use? The current lineup as of June 2026 — including Claude Fable 5, Opus 4.8, Sonnet 4.6, and Haiku 4.5; see everything that changed in June 2026.
Get alerted when Claude pricing or limits change
We track Anthropic’s models, pricing, and limits daily and send a short note when something changes that affects what you pay or build. Occasional, no spam.
Last verified: June 11, 2026 (Pacific Time). This is the June edition of our monthly Claude updates series — the May 2026 edition covered the Opus 4.8 launch, the SpaceX compute deal, and Managed Agents memory features.
June 2026 is one of the biggest months for Anthropic since the Claude 4 launch: a new top-tier model is generally available, two workhorse models retire in four days, and Managed Agents can now run inside infrastructure you control. Here is everything that changed, with dates and migration paths.
Claude Fable 5 — the Mythos-class model goes public (June 9, 2026)
Anthropic released Claude Fable 5 on June 9, 2026 — the public version of what had been known as its Mythos-class model tier. It is positioned as a new tier above Opus, and it is Anthropic’s most capable generally available model. According to CNBC’s launch coverage, Fable 5 scored more than 10% higher than Claude Opus 4.8 on some benchmarks, with exceptional performance across software engineering and knowledge work. Anthropic credits new safeguards that block responses in specific high-risk areas for making a broad release possible.
The practical details developers need:
Model ID:claude-fable-5
Availability: enterprise customers and paid subscribers
Context window: 1 million tokens; maximum output 128K tokens
API pricing: $10 per million input tokens / $50 per million output tokens
API surface: adaptive thinking only — temperature, top_p, top_k, and budget_tokens are not accepted, and unlike Opus 4.8, an explicit thinking: {type: "disabled"} returns a 400 error. Omit the thinking parameter entirely if you do not want it.
For where Fable 5 sits against every other Claude model on price, see our continuously updated Claude AI pricing guide, and our complete Fable 5 guide for capabilities and use cases.
June 15 deadline: Claude Opus 4 and Sonnet 4 retire in four days
If you are still calling claude-opus-4-20250514 or claude-sonnet-4-20250514, those models retire from the Claude API on June 15, 2026. Requests after retirement return 404 errors. The drop-in replacements:
claude-opus-4-20250514 → claude-opus-4-8
claude-sonnet-4-20250514 → claude-sonnet-4-6
Note that both replacements use adaptive thinking rather than manual thinking budgets, and the 4.6+ models reject assistant-turn prefills — so this is a small migration, not just a string swap. Anthropic also deprecated Claude Opus 4.1 this month, with API retirement scheduled for August 5, 2026 — worth adding to your migration calendar now.
Current Claude model lineup and API pricing (June 2026)
Model
Model ID
Context
Max output
Input $/1M
Output $/1M
Claude Fable 5
claude-fable-5
1M
128K
$10.00
$50.00
Claude Opus 4.8
claude-opus-4-8
1M
128K
$5.00
$25.00
Claude Sonnet 4.6
claude-sonnet-4-6
1M
64K
$3.00
$15.00
Claude Haiku 4.5
claude-haiku-4-5
200K
64K
$1.00
$5.00
Opus 4.7, 4.6, 4.5, and 4.1 and Sonnet 4.5 remain active for pinned workloads. We track which model is current at any moment in our current Claude model version reference.
Managed Agents: self-hosted sandboxes and private MCP servers
Claude Managed Agents — Anthropic’s server-managed agent platform — can now execute tools inside a sandbox you control. The agent loop still runs on Anthropic’s orchestration layer, but bash commands, file operations, and code execution happen in your own container, behind your own firewall, with your own egress rules. Your worker long-polls Anthropic’s work queue over outbound-only connections; Anthropic never dials into your network. Managed Agents can also now connect to private MCP servers, which matters for any organization whose internal tools are not on the public internet.
For regulated industries — healthcare, finance, legal — this is the missing piece that lets you adopt hosted agents while keeping data residency: files and tool output never leave infrastructure you own.
Claude Code: nested sub-agents and plugin search
Claude Code shipped a steady stream of updates in June: nested sub-agents (agents can now spawn their own sub-agents for deeper task decomposition), smarter model and region handling, a new plugin search, and improved Chrome, VS Code, and terminal workflows.
Legal expansion: 20+ MCP connectors and 12 practice-area plugins
Anthropic released more than 20 new legal MCP connectors and 12 practice-area plugins, covering research, contracts, discovery, matter management, and legal aid. The pattern to note: Anthropic is increasingly shipping vertical integration bundles rather than leaving connector-building entirely to the ecosystem.
Claude Corps: $150M for nonprofit AI adoption
Anthropic announced Claude Corps, a $150 million fellowship program that will embed roughly 1,000 trained fellows inside nonprofit organizations for a year to help them use AI effectively. Applications and program details are rolling out through Anthropic’s newsroom.
Apple Foundation Models integration
Claude support is coming to Apple’s Foundation Models framework on iOS 27, iPadOS 27, macOS 27, and visionOS 27 — meaning third-party Apple developers will be able to call Claude through Apple’s native AI framework rather than integrating the API directly.
What to watch for in July
August 5, 2026: Claude Opus 4.1 retires from the API — migrate to claude-opus-4-8 before then.
Fable 5 ecosystem: expect Claude Code, Cowork, and Managed Agents to expose Fable 5 more broadly through July as capacity scales.
Apple rollout: developer betas of the iOS 27 family will show what Claude-via-Foundation-Models actually looks like in practice.
Last week I argued that if you have more than a handful of engineers on Claude Code, repo-level .claude/settings.json is not enough — you need managed-settings.json deployed through MDM. That is still true. What changed in 2026 is that you no longer need an MDM team to roll it out.
Claude Code now supports server-managed settings: a remote configuration tier pushed from the Claude.ai admin console, with no file on disk and no MDM involvement. If you are on the Team plan running Claude Code 2.1.38+ or the Enterprise plan running 2.1.30+, this is available to you today, and most platform teams I talk to are still treating MDM-deployed managed-settings.json as the only option.
It is not. And the precedence rules matter.
The New Top of the Settings Hierarchy
Claude Code’s settings stack already had a clear order — repo > user > project > local — with managed settings sitting on top of all of them as the unoverridable tier. Server-managed settings now sit at the same top tier alongside MDM and the on-disk managed-settings.json file. Within that managed tier, the documented precedence is:
Server-managed settings (admin console push)
MDM / OS-level policies (Jamf, Kandji, Group Policy, Intune)
managed-settings.json on disk (the file we deployed last week)
HKCU registry (Windows)
Server-managed wins. If you push a policy from the admin console that conflicts with a fleet managed-settings.json deployed by MDM, the server policy applies. That is the entire point.
What This Actually Replaces
For organizations without a mature endpoint management pipeline — which is most companies smaller than a couple hundred engineers — the old path looked like this: get IT to package a JSON file, push it through Jamf or Group Policy, verify on a pilot machine, then deploy fleet-wide. Two-week ticket minimum.
Server-managed settings collapse that to: log into the admin console, write the policy in the UI, save. Claude Code clients fetch the new policy at startup and re-poll hourly during active sessions. No reboot. No reinstall. No ticket.
This is a real change in posture. The friction that kept smaller teams from deploying any managed policy at all just dropped to near zero.
The Approval Gate Most Teams Will Hit
Server-managed settings have one behavior MDM-deployed settings do not: certain categories require explicit user approval before they apply on a given machine. The current list per the docs:
Shell command settings (custom commands surfaced to the model)
Custom environment variables (anything injected into the model’s process env)
Hook configurations (pre/post-tool-use hooks)
These three need the user to click through an approval prompt the first time the new policy hits their client. Deny rules in permissions.deny, the audit log path, telemetry settings, default model — those apply silently.
The reasoning here is sound: a malicious admin (or a compromised admin account) could otherwise inject a hook that exfiltrates every prompt or a shell command that pipes diffs to an external endpoint. Approval gating those three categories means a developer at least sees the change before it takes effect. It also means your “push the new hook policy fleet-wide” plan has a manual confirmation step you cannot skip.
If you need silent enforcement of hooks or shell commands, MDM-deployed managed-settings.json still does that without the prompt. Use the right tool for the right setting.
What Belongs on the Server, What Belongs in MDM
After running both for two weeks across a small fleet, the split that has held up:
Push from the admin console:
permissions.deny rules that should be hot-updatable when a new exfil vector is discovered
Default model pinning (when you want to change it without re-deploying)
Telemetry and audit log endpoints
Anything you want to A/B across user groups (more on this in a second)
Keep in MDM managed-settings.json:
Hook configurations you need to enforce silently
Shell command allowlists that must apply before first launch
Anything that needs to survive the user being signed out of their org account
The reason for the second list is that server-managed settings only apply once the user authenticates with org credentials. A fresh laptop with a developer running claude before signing in gets no server policy. MDM-deployed settings apply from the first invocation.
Group-Targeted Policies Are the Sleeper Feature
Anthropic added user groups to the admin console earlier in 2026. Groups can be created manually or synced from an IdP via SCIM, and each group can be assigned a custom role plus its own spend limit. The piece most teams have not connected yet: server-managed settings respect group membership.
This means you can push one permissions.deny policy to the “Security” group and a different one to the “Platform” group without writing two separate managed-settings.json files and pushing them through MDM with different scoping. Write two policies in the console, assign to groups, done. Group membership changes via SCIM propagate within the hour-long polling window.
For a 200-engineer org that previously needed Jamf smart groups + MDM JSON variants to do the same thing, this is significant.
Verification Workflow
The same verification workflow from the MDM-deployed setup still applies, with one addition:
Push the policy in the admin console
On a test machine, run claude config list — server-managed settings should appear flagged as such
Attempt a denied action, confirm immediate block
If hooks or shell commands are in the policy, walk through the approval prompt
Sign the test user out, sign back in, confirm policy reapplies
The sign-out test matters because that is where server-managed differs most from on-disk managed settings — the policy is bound to the org-authenticated session, not the machine.
Model Versions for Org-Wide Pinning
If you pin a default model via server-managed settings, the current strings are: claude-opus-4-7 (flagship), claude-sonnet-4-6 (workhorse), and claude-haiku-4-5-20251001 (fast). Verify against the live model list at docs.anthropic.com/en/docs/about-claude/models before deploying — model strings change frequently and pinning to a deprecated one will silently break agent runs.
Where Server-Managed Settings Lose
Three real limitations:
No silent hook/shell-command enforcement. User approval is mandatory for those three categories.
No effect before org auth. Pre-auth sessions ignore server policy entirely.
No fine-grained rollback. Console changes apply globally within the hour. There is no canary group, no staged rollout percentage, no “apply to 10% of fleet for 24 hours” toggle. If you push a bad deny rule, every active session picks it up at next poll.
Mitigate the third one by maintaining a single non-production test group that you deploy to first, wait 90 minutes, then promote the policy to broader groups. It is a manual canary, but it is the canary you have.
The 20-Minute Rollout for a Team Already on Team Plan v2.1.38+
Open the admin console at claude.ai → Settings → Claude Code policies
On that user’s machine, run claude config list — confirm the server policy appears
Try three denied actions, confirm all blocked
Expand assignment to one team
Wait 24 hours, watch for tickets
Roll org-wide
The whole sequence takes longer than it runs because of the wait windows, not because of the work. The actual work is twenty minutes.
Why This Article Exists
The MDM-deployed managed-settings.json approach from last week is still the right answer for orgs that need silent, pre-auth policy enforcement. For everyone else — which is most teams adopting Claude Code in 2026 — server-managed settings are the easier path and most platform teams I talk to do not know they exist yet. Admin console push, no on-disk file, no MDM dependency, group-scoped via SCIM. If you are on a recent Team or Enterprise plan, this is the deployment posture you actually want.
Sources
docs.anthropic.com/en/docs/about-claude/models (model version strings)
If you have spent any time in the Claude Code subreddit or the GitHub issues tracker in the last six months, you have seen the same Windows install problem cycle through every week. Someone runs the install command, the installer prints “successfully installed,” and then claude --version returns “is not recognized as the name of a cmdlet.” Then come the suggestions: switch to Git Bash, switch to WSL2, reinstall Node, blow away npm. Half of them are wrong for the current installer. This guide is the one I wish existed when I set up Claude Code on a fresh Windows 11 machine this month.
What changed in 2026: the native installer is now the default
Anthropic shipped a native installer in 2025 that removed the Node.js dependency entirely. As of May 2026 it is the recommended path on every platform, and npm install of @anthropic-ai/claude-code is still supported but is no longer the primary method Anthropic tests and updates. The native installer downloads a single binary, drops it in ~/.local/bin, registers it on your PATH, and auto-updates in the background.
What this means in practice on Windows: you do not need Node, you do not need npm, and you do not need WSL2 unless you specifically want a Linux toolchain. PowerShell on Windows 10 or 11 (64-bit) is enough.
The two commands that actually work
Open Windows PowerShell — not the x86 version, not Git Bash, not Command Prompt. The x86 entry runs as a 32-bit process and will fail on a 64-bit machine. Git Bash does not support the TTY features Claude Code’s interactive CLI needs, so you will hit the “Raw mode is not supported” error before you finish authenticating.
Then run:
irm https://claude.ai/install.ps1 | iex
That is the entire install. irm is Invoke-RestMethod, iex is Invoke-Expression, and the script handles the binary download, PATH update, and shell hooks. When it finishes, close the terminal and open a new PowerShell window. This is the step everyone skips. The PATH change applies to new shells only — your current session still has the old PATH and will not find the binary.
In the new window:
claude --version
You should see a version string. Then run claude with no arguments from any project directory. The CLI opens your default browser, asks you to sign in to your Anthropic account, and authorizes the local install. Setup, end to end, is under five minutes on a clean machine.
You need a paid account — the free tier does not include Claude Code
This catches new users every week. The free Claude.ai plan gets you chat on web, iOS, Android, and desktop. It does not get you Claude Code. To use the terminal CLI you need one of:
A Pro subscription at $20 per month (or $17 per month billed annually). A Max 5x subscription at $100 per month. A Max 20x subscription at $200 per month. A Team Premium seat at $100 per seat per month annual or $125 monthly, minimum five seats. Or API credits — new API accounts get a small free credit pool to test with, but you are billed per token from there.
Pro and Max draw from the same token budget as your regular Claude chat usage. The Pro window is roughly 44,000 tokens per five-hour rolling window, which third-party tracking puts at 10 to 40 prompts depending on codebase complexity. Max 5x and 20x scale that linearly. If you are evaluating whether to upgrade, the Pro window will tell you within a week — you either hit the cap during real work or you do not.
The five errors you will hit, and what fixes them
“claude is not recognized as the name of a cmdlet.” Your PATH was not updated, or you did not open a new terminal. First, close PowerShell and reopen. If the error persists, the install location exists but your user PATH does not reference it. Run this in PowerShell:
Close the terminal again, open a new one, and claude --version should work.
“Raw mode is not supported.” You are running Claude Code inside Git Bash. Git Bash does not provide the TTY interface the CLI needs. Switch to Windows PowerShell. Everything you would do in Git Bash you can do in PowerShell; you just need to use Windows path syntax inside the prompt.
Microsoft Store popup interrupts installation. A popup saying “Get an app to open this ‘claude’ link” sometimes appears during the install on Windows 11. This is a known issue tracked in Anthropic’s GitHub. Dismiss the popup, then re-run the install command. If it persists, install Git for Windows first — the installer registers a couple of URL handlers that resolve the popup.
Duplicate npm and native installs. If you previously installed via npm and later ran the native installer, you have two binaries on PATH. The native one wins on some shells and the npm one wins on others, which produces confusing version mismatches. Remove the npm install:
npm uninstall -g @anthropic-ai/claude-code
Then verify with where.exe claude in PowerShell. Only one path should come back.
“Invalid code” during OAuth. The browser-based login generates a one-time code that you paste back into the terminal. The code expires fast and is sensitive to copy-paste truncation. Press Enter to retry, complete the browser flow, and paste the code immediately — do not let it sit in your clipboard while you check email.
What to do in the first session
Once claude --version returns and the OAuth flow completes, run claude from inside a real project directory — not a fresh empty folder. Claude Code reads context from the surrounding repo, and the first thing it does in a useful session is index files and look for a .clauderules or CLAUDE.md. If you start in an empty directory the first interaction feels useless because there is nothing to ground the model on.
If you want to lock to a specific model rather than the default, the current strings as of May 2026 are claude-opus-4-7 for the flagship, claude-sonnet-4-6 for the workhorse, and claude-haiku-4-5-20251001 for the fast tier. Sonnet 4.6 is what you want for almost all coding work — it is 30 to 50 percent faster than Sonnet 4.5 and ships with a 1M context window. Reserve Opus 4.7 for the hardest agentic refactors; it eats tokens noticeably faster.
The setup is not the hard part
Most of the Windows pain in the Claude Code ecosystem comes from people following install guides written for the npm-era CLI, then layering troubleshooting from the WSL2-era guides on top of that, then asking why nothing works. The current path is one PowerShell command, a new terminal, and a browser login. If you hit one of the five errors above, the fix is short. If you hit something else, the troubleshooting docs at code.claude.com cover it — most novel issues turn out to be PATH or shell-choice problems in a slightly different costume.
The next thing to figure out is not installation. It is whether your Pro window survives a real week of work, and whether your team needs Premium seats. That math is what determines the actual cost of Claude Code on Windows — not whether the binary runs.
Most engineers who install MCP servers in Claude Code stop at GitHub. That’s a mistake. The GitHub server is the easy first install — but the integration that actually changes how I work is Sentry, and the pattern that emerges once it’s wired up tells you everything about how to think about MCP.
Here’s the workflow I’m running this week: an alert fires in Sentry, I paste the issue ID into Claude Code, and the agent reads the stack trace, pulls the offending file from the repo, writes the fix, opens a PR, and links the PR back to the Sentry issue. I never opened the Sentry dashboard. I never copy-pasted a stack trace. Two MCP servers, one terminal, one round trip.
Why Sentry is the high-value second install
GitHub MCP makes Claude Code a contributor. Sentry MCP makes it an on-call responder. The difference matters because the most expensive minutes in any engineering org are the ones between “alert” and “first line of investigation.” That gap is almost entirely context-switching cost — tab to the alerting tool, find the right issue, copy the stack trace, paste it somewhere the LLM can see it, then start.
The Sentry MCP server is a remote HTTP server hosted by Sentry, which means there’s no Docker container to maintain and no local process to babysit. You authenticate once with a personal access token and Claude Code can pull issue details, search across projects, fetch event payloads, and read breadcrumbs directly into context.
The install — three commands, two integrations
Here’s the actual setup. GitHub first:
claude mcp add github \
-e GITHUB_PERSONAL_ACCESS_TOKEN=ghp_your_token \
--scope user \
-- docker run -i --rm \
-e GITHUB_PERSONAL_ACCESS_TOKEN \
ghcr.io/github/github-mcp-server
Then Sentry. Sentry runs as a remote HTTP server, so the syntax is different:
claude mcp add --transport http sentry https://mcp.sentry.dev/mcp \
--scope user \
-H "Authorization: Bearer YOUR_SENTRY_PAT"
Verify with claude mcp list. You should see both servers reporting healthy. If Sentry returns a 401, the token doesn’t have the right project scopes — Sentry’s tokens are project-scoped, not org-scoped, so this trips up people who are used to GitHub PATs.
One configuration detail worth noting: I use --scope user for both. Project scope writes to .mcp.json in the repo, which is fine for team-wide tools but wrong for personal credentials. User scope keeps the token in your own config and out of the repo.
The prompt pattern that makes it work
The naive approach is “fix Sentry issue 12345.” That works but burns tokens because Claude has to discover the tool, fetch the issue, parse the stack trace, identify the file, and only then start reasoning about the fix. With Tool Search — the on-demand tool discovery that ships with Claude Code — the cost is lower than it used to be, but it’s still slower than necessary.
The pattern I’ve settled on is more directive: “Pull Sentry issue PROJECT-12345, identify the file and line from the stack trace, read the surrounding context, and draft a fix as a branch off main. Don’t open the PR yet.” That gives Claude a strict sequence and lets me review the branch before anything goes to GitHub.
The “don’t open the PR yet” part matters. When you chain two write-capable MCP servers, the failure mode is that Claude races ahead and pushes a half-baked fix because it has the tools and the authority. Constraining the action surface in the prompt is how you keep this useful instead of dangerous.
What breaks, and how to know
Three things have failed for me in the last month and each one is worth knowing.
First: Sentry rate-limits aggressively. If you’re working through a long incident and Claude is making repeated calls, you’ll hit the limit and the tool calls will start returning errors mid-conversation. The fix is to ask Claude to dump everything it needs from Sentry in one call, then work from that context. The token cost is higher upfront but the workflow is more reliable.
Second: GitHub MCP via Docker has a cold-start cost on the first call of a session — typically two to four seconds while the container spins up. This is fine but it does mean the first response feels slow. If you’re on a Mac with Apple Silicon, the container image is multi-arch and works without the --platform linux/amd64 flag.
Third: when both servers are connected and you have other MCP servers installed, Claude will sometimes route a Sentry-shaped question through GitHub’s search instead. The fix is to name the tool in the prompt — “use the Sentry MCP to fetch issue X” — rather than trusting the routing. This is a known cost of running many servers and is the trade-off you accept for breadth.
The pricing reality
Sentry MCP is free to use if you have a Sentry account — there’s no additional charge for the MCP layer. The cost comes from the Claude API tokens you burn pulling Sentry data into context. A typical issue investigation runs 8,000 to 15,000 input tokens depending on stack trace length and breadcrumb count. On Sonnet 4.6 that’s roughly $0.02 to $0.05 per investigation, which is trivial compared to the engineering time saved.
GitHub MCP is the same story — free server, you pay only for tokens. The Docker image is open source under github/github-mcp-server on GHCR.
What I’d install next
After GitHub and Sentry, the next install that earns its keep is Postgres if you have a database, or Linear if your team uses it for issue tracking. The pattern is the same in every case: the MCP server you want is the one that eliminates the highest-frequency context switch in your day, not the one with the most features. Audit your own tab-switching for a week. Whichever app you alt-tab to most often is the next MCP server worth wiring in.
The deeper lesson is that MCP changes the shape of what a coding agent is for. Without integrations, Claude Code is a smart autocomplete. With two well-chosen MCP servers, it becomes the connective tissue between alert, code, and ship — which is most of what engineering work actually is.
Almost every developer I trust has both Claude Code and Cursor open at the same time. The “which is better” question is the wrong one. The real question is which tool earns which job, and that answer has shifted twice in the last six weeks. Cursor 3.0 landed on April 2 with the Agents Window, Anthropic shipped Agent View into Claude Code on May 11, and Cursor Composer 2.5 dropped on May 18 — yesterday. If you locked in your mental model of these tools at the start of the year, it is already stale.
Here is the honest version of where they stand right now, where each one loses, and how I am actually using them in May 2026.
The pricing is closer than the discourse suggests
Both Pro tiers start at $20/month. Cursor knocks that to roughly $16 on annual billing, Anthropic to $17 on annual. From there the price ladders are nearly mirror images: Cursor sells Pro+ at $60 and Ultra at $200; Claude Code sells Max 5× at $100 and Max 20× at $200. Cursor Business is $40/seat with admin controls and centralized billing. Claude Code routes team buyers through Team Premium, which lands somewhere between $100 and $150 per seat depending on configuration.
For a ten-person engineering team, that math gets real. Cursor Business at $40 × 10 is $400/month. Claude Code via Team Premium is roughly $1,000–$1,500/month for the same headcount. That is a 2.5×–3.75× spread, and it is the single biggest reason Cursor still wins net-new enterprise pilots in 2026. Sticker shock is a feature, not a bug, in procurement.
Token efficiency cuts the other way. In side-by-side benchmark runs, Claude Code on Opus 4.7 has been hitting roughly 5× lower token usage than Cursor’s agent on identical tasks — one widely circulated benchmark showed 33K tokens vs 188K tokens for the same refactor. If you are on metered API pricing rather than a flat plan, the headline seat price is misleading. The plan tier you actually need depends on whether your team mostly types alongside the agent (Cursor’s strength) or dispatches autonomous jobs and walks away (Claude Code’s strength).
The May 2026 feature gap, honestly
Claude Code spent the spring building out parallelism. The headline is Agent View, which shipped in Claude Code v2.1.130 on May 11. Running claude agents opens a single CLI dashboard showing every background session, which ones are waiting on input, and which are still grinding. You can dispatch a session, send it to the background, and pull it forward only when it has a question. Combined with subagents — which already let you scope tool access and route to claude-haiku-4-5-20251001 for cheap exploration work before handing off to claude-opus-4-7 for the actual edits — you now get both horizontal parallelism between sessions and vertical parallelism inside one. The /goal command, also from this release window, lets you define outcome-based tasks that run with minimal supervision. Rate limits doubled in the same release window.
Cursor’s answer is the Agents Window from Cursor 3.0 (April 2), expanded yesterday by Composer 2.5. The Agents Window is the same idea as Agent View but lives inside the IDE rather than the terminal — multiple background agents, each in its own sandboxed checkout, running tests and shell commands while you keep editing. Composer 2.5 is Cursor’s house frontier model, tuned for low-latency agentic loops; Anthropic claims most turns complete in under 30 seconds, with a smaller Composer 2 variant doing cheap coordination work and calling out to stronger third-party models only when needed.
The contours: Claude Code’s parallelism story is built around a CLI agent that lives in your repo and treats the editor as optional. Cursor’s parallelism story is built around an IDE that treats the agent as one of several panes. Neither approach is obviously correct. Which one feels right depends on whether you already live in your terminal or your editor.
MCP support is finally a tie
This was Claude Code’s structural advantage all the way through 2025 — native Model Context Protocol support, which let you wire the agent to Postgres, Notion, Linear, internal APIs, anything that spoke MCP. That moat is gone. Cursor shipped native MCP support during the 3.0 cycle and the rough edges are now mostly sanded down. Both tools can query your database schema mid-session, both can hit your Linear or Notion workspace, both let you write custom MCP servers for internal tooling.
The remaining difference is ecosystem inertia. The Anthropic-published MCP servers tend to land in Claude Code first, and the third-party MCP server registry skews toward Claude Code usage patterns. If you are wiring up esoteric internal systems, expect to write more glue code on the Cursor side. If you are connecting standard SaaS, both tools are fine.
Where Claude Code still wins outright
One-million-token context on Opus 4.7, generally available since March, with no surcharge — a 900K-token request costs the same per-token rate as a 9K one. For codebases above roughly 200K tokens of relevant context, this is decisive. Cursor in “auto” mode picks a model and manages context for you, which is fine for small repos and unreliable for large ones. When I am asking a question that genuinely requires the agent to hold most of a service in its head — cross-service refactors, undocumented legacy code, migration planning — I open Claude Code.
The other Claude Code win: the agent will happily run for an hour on a hard problem without checking in, then come back with a working branch. Cursor’s agent prefers shorter loops and more interaction. That is a design choice, not a defect on either side, but it makes Claude Code the right answer for “go fix this entire test suite while I am in standup.”
Where Cursor still wins outright
Anything where you want the agent to be a faster you, not a substitute for you. Inline completion is still better in Cursor. Tab completion is still better in Cursor. The “watch my edits and infer the pattern” loop is still tighter in Cursor. If 80% of your day is writing code with occasional AI assistance, the IDE wraps the model better than a CLI does, no matter how good the CLI gets.
The other Cursor win: cost discipline at scale. Composer 2 doing cheap coordination and calling out to Opus or GPT only when needed is a smart cost-management pattern, and it shows up in your monthly bill. Cursor’s @codebase, @docs, @web, and @file mentions let you constrain the context window manually, which means fewer tokens chewed up by speculative retrieval.
How I actually use them
Cursor for the 80% — daily edits, feature work, bug fixes where I am still doing most of the thinking. Claude Code for the 20% — anything where I want to dispatch the agent and stop watching. Migrations. Test suite repair. Schema refactors that touch fifteen files. Anything where the right loop is “kick it off, go to lunch, come back to a PR.”
The decision rule that keeps me sane: if I will be in the editor anyway, I use Cursor. If I would otherwise be doing something else while waiting, I use Claude Code’s Agent View and let it run.
The tools are converging on feature parity at the surface — both have agent dashboards, both speak MCP, both have background sessions, both ship frontier models. The differences left are about texture: where you live (terminal vs editor), how much autonomy you want to grant in a single turn, and whether your spend looks more like a flat subscription or a metered API line item. Pick the texture that matches how your day already runs. Switching cost is low. Switching pain is real.
There is a workflow gap most Claude Code users walk straight into and never quite close. CLAUDE.md tells Claude what should happen. Plan mode lets you see what Claude intends to do. Hooks decide what Claude is physically allowed to do. Pick any one of those in isolation and you get a tool that is impressive in a demo and unreliable in a real repo. Pair plan mode with hooks the right way and Claude Code stops being a chat surface and starts behaving like a constrained junior engineer you can leave alone for an hour.
This is the workflow I have moved every non-trivial repo onto. It is not the simplest setup — that would be raw claude with a CLAUDE.md and trust. It is the setup that survives the moment Claude decides, with great confidence, to delete the wrong file.
The three layers, and why most people only use two
Claude Code as a programmable platform has three durable surfaces for shaping its behavior in 2026:
CLAUDE.md — the markdown memory file Claude reads at the start of every session. Project conventions, glossary, “don’t touch this directory,” coding style.
Plan mode — the read-only review gate, activated with Shift+Tab twice or /plan. No edits, no shell, no git. Claude proposes an implementation plan against the live codebase and waits.
Hooks — deterministic shell scripts that fire on specific tool calls or session events. Pre-commit linting, blocking edits to generated files, refusing pushes to main.
The standard pattern I see in repos is CLAUDE.md plus vibes. Sometimes plan mode for the big tasks. Almost no one is running hooks until they have been burned once. That is the wrong order. Hooks are not advanced — they are the thing that lets plan mode actually mean something.
The reason is empirical and uncomfortable: CLAUDE.md instructions get followed roughly 70% of the time. That is acceptable for “prefer arrow functions” and catastrophic for “don’t push to main.” Plan mode raises the floor on the high-stakes decisions because you see the plan before any tool runs. Hooks raise the ceiling on the boring ones because they execute regardless of Claude’s intent.
What the pairing actually looks like
The mental model: plan mode is for novel work where you need to inspect the strategy. Hooks are for recurring boundaries you do not want to inspect ever again. If you find yourself reviewing the same kind of decision in plan mode twice, that decision belongs in a hook.
A concrete setup from one of my repos:
CLAUDE.md — short. Project glossary, the test command, the “production data is in prod/ and is read-only” rule, the rule that all new files in src/ need a test in tests/. Maybe forty lines. No essay.
Plan mode discipline — anything that touches more than three files, anything that changes a public interface, anything that touches the database schema, I open with /plan. I read the plan. I push back. Then I let it run. For one-file edits, bug fixes I have already scoped, or doc changes, I skip planning. The cost of planning a two-line fix is higher than the cost of undoing it.
Hooks doing the actual enforcement. This is where the work lives. The hooks I run on every active repo:
A PreToolUse hook on Bash that blocks any command matching git push.*main, rm -rf, or any reference to a path under prod/. Returns a non-zero exit and tells Claude what to do instead.
A PreToolUse hook on Edit and Write that refuses any file path matching the generated-code globs from .gitattributes. If the file is autogenerated, Claude is rewriting source-of-truth, not output.
A PostToolUse hook on Edit that runs the linter on just the touched file and surfaces the diagnostics back to Claude. Cheap, fast, closes the loop without waiting for the next test run.
A Stop hook that runs the test suite. Claude does not get to mark the task done if tests are red. This single hook eliminated about 80% of my “it said it was done but” moments.
That last one is the one I would put in every repo before anything else. Without it, Claude verifies its work using its own judgment, which degrades as context fills. With it, each red-to-green cycle is an unambiguous external signal that the work is actually done.
Where this pairing earns its keep
Two scenarios where the plan-mode-plus-hooks combination pays for the setup time:
The unfamiliar-codebase refactor. Claude in plan mode reads the codebase, proposes a refactor across eight files, lists what it will touch and what it will leave alone. You scan the plan, notice it wants to modify a file in a directory that should be read-only, and instead of arguing in chat you add a hook. The hook is now permanent. The next session cannot make the same mistake.
The long-running, multi-step job. You send Claude off to add a feature with twelve subtasks. You are not watching. The Stop hook running tests means Claude either finishes with a green suite or stops and reports. The push-to-main hook means even if Claude decides the merge looks fine, it physically cannot ship it. You get back, read the report, merge. The autonomy is real because the guardrails are real.
What this pattern is not
It is not a replacement for reading Claude’s diffs. Hooks catch categorical mistakes — wrong directory, wrong branch, wrong command — and miss subtle ones, like a refactor that compiles and passes tests but breaks a contract no test covered. Plan mode catches strategic mistakes — wrong approach, wrong scope — and misses tactical ones, like an off-by-one. You still review code. You just stop spending review time on things a script can check.
It is also not a substitute for subagents or skills. Hooks are deterministic enforcement. Subagents are context isolation for parallel work. Skills are reusable procedural knowledge. The Anthropic team’s own framing — start with skills, add hooks when you need deterministic enforcement, add subagents when parallel work or context isolation matters — is correct, and the three layers compose. But the order most practitioners actually need is the inverse of the order they reach for. Most teams reach for subagents first because they sound powerful. Hooks are what makes any of it trustworthy.
The setup that gets you to a usable baseline
If you have one hour, do this in this order:
First, write a forty-line CLAUDE.md. The test command, the build command, the directory rules, the glossary. Do not try to write an essay about your codebase. Claude will read it every session — keep it dense.
Second, add three hooks: a PreToolUseBash hook blocking destructive commands on your protected paths, a PostToolUseEdit hook running the linter on the touched file, and a Stop hook running the test suite. Twenty lines of shell each. None of them require any framework — they are just executables that read JSON from stdin and exit non-zero to block.
Third, develop the habit of /plan for anything you would not be comfortable letting a new contractor commit without review. For everything else, let it run.
That is the baseline. You can layer on subagents, MCP servers, skills, custom slash commands — all of it is useful, none of it is required to ship reliably. The reliability comes from the boring layer: a memory file Claude reads, a plan mode you actually use, and hooks that mean what they say.
The Claude Code documentation will teach you the syntax for any of this in an afternoon. The pattern is the part that took a year of watching it go wrong to settle on.
Sources: Anthropic’s Claude Code documentation, the model list at the Anthropic docs site (verified at runtime), and a year of repos.
May 2026 has been one of Anthropic’s busiest months yet. Here’s everything that shipped, changed, or was announced — plus the confirmed upcoming dates you need to know.
June 2026 Update
Since this page was published, Anthropic has released Claude Opus 4.8 — the new current flagship model, succeeding Opus 4.8. Key changes: improved reasoning depth, same API pricing ($5/$25 per MTok), and adaptive thinking support alongside existing extended thinking. See the current model version tracker for the full model lineup.
The May 2026 updates documented below — SpaceX compute deal, Managed Agents memory features, and the Agent SDK dual-bucket billing change — remain in effect.
Claude Opus 4.8 — Generally Available (April 16, 2026)
Opus 4.8 launched April 16 as the current flagship model, priced identically to Opus 4.6 at $5/$25 per million tokens (input/output). Key changes:
Vision resolution: 3× higher at 2,576px (~3.75 megapixels), raising XBOW visual acuity benchmark performance from 54.5% to 98.5%
Coding: 70% on CursorBench (vs 58% for 4.6), resolves 3× more production tasks on Rakuten-SWE-Bench, +13% lift on Anthropic’s internal coding benchmark
Legal reasoning: 90.9% on BigLaw Bench
New effort level:xhigh sits between high and max — five levels total: low / medium / high / xhigh / max
Task budgets: Now in public beta — token spend guidance for longer agentic runs
Tokenizer update: New tokenizer increases token usage roughly 1.0–1.35× for the same content; API pricing unchanged
Breaking change: Opus 4.8 has API breaking changes versus 4.6 — review Anthropic’s migration guide before upgrading
Alongside Opus 4.8, Anthropic launched Claude Design — an Anthropic Labs product for collaborating with Claude to produce visual outputs including designs, prototypes, slides, and one-pagers.
Anthropic announced a partnership with SpaceX to access Colossus 1 compute capacity. The immediate practical impact for subscribers:
Claude Code’s five-hour rate limits doubled for Pro, Max, Team, and seat-based Enterprise plans
Peak-hour limit reductions removed for Pro and Max (previously limits burned faster 5am–11am Pacific on weekdays)
Opus API limits raised for heavy API users
Anthropic is also reportedly evaluating an IPO as early as October 2026, and has disclosed run-rate revenue of $30B (up from $9B at end of 2025). The SpaceX deal comes as the company prepares that filing.
Claude Managed Agents — the fully managed agent harness launched in public beta earlier this year — gained three significant additions:
Dreaming (research preview): A scheduled process that reviews past agent sessions, extracts patterns, and curates memories so agents self-improve over time. Dreaming can update memory automatically or queue changes for human review before they land.
Multiagent Orchestration: A lead agent can now break a job into pieces and delegate each to a specialist sub-agent with its own model, prompt, and tools. Specialists work in parallel on a shared filesystem. Netflix is already using multiagent orchestration for its platform team.
Memory (public beta): Now generally available under the managed-agents-2026-04-01 beta header.
Claude Cowork — Generally Available
Claude Cowork is now GA on macOS and Windows through the Claude Desktop app. New additions with GA: Claude Cowork in the Analytics API, usage analytics, and expanded desktop automation capabilities.
Claude Code — What Shipped in May
Claude Code has been shipping near-daily updates. Notable May additions include:
Plugin URL loading:--plugin-url <url> flag fetches a plugin .zip from a URL for the current session
Project purge:claude project purge [path] deletes all Claude Code state for a project (transcripts, tasks, file history, config) with dry-run support
Package manager auto-update:CLAUDE_CODE_PACKAGE_MANAGER_AUTO_UPDATE runs upgrade in the background on Homebrew or WinGet installs
Push notifications: Claude can now send mobile push notifications when Remote Control is enabled
VS Code Remote Control:/remote-control bridges sessions to claude.ai/code to continue from a browser or phone
1M token context in Claude Code: Available to Max, Team Premium, and Enterprise Opus 4.6/4.7 users at no additional cost — no long-context surcharge as of March 2026
Redesigned desktop app: New session sidebar, drag-and-drop workspace, integrated terminal and file editor, faster diffs, SSH support on Mac
New Connectors Expansion
Claude’s connector directory has grown beyond work tools. New consumer app connectors include AllTrails, Instacart, Audible, Tripadvisor, Uber, and Spotify. The directory now exceeds 200 connectors. Claude surfaces relevant connectors in context during conversations rather than requiring users to browse a directory.
Finance Agent Templates
Anthropic released ten ready-to-run agent templates for financial services work: pitchbook building, KYC file screening, and month-end close workflows. Microsoft 365 add-ins for Excel, PowerPoint, Word, and Outlook are coming soon. A Moody’s MCP app brings Claude into financial data workflows.
Confirmed Upcoming Dates
These are officially announced by Anthropic — not speculation:
June 15, 2026: Claude Sonnet 4 (claude-sonnet-4-20250514) and Claude Opus 4 (claude-opus-4-20250514) are deprecated and retired from the Claude API. Migrate to Sonnet 4.6 and Opus 4.8 respectively before this date.
Microsoft 365 add-ins: Excel, PowerPoint, Word, and Outlook integrations announced as “coming soon” — no specific date published.
Anthropic IPO: Reportedly targeting as early as October 2026 — unconfirmed, no official date.
Google/Broadcom TPU partnership: Multi-gigawatt infrastructure with capacity launching in 2027.
Model Deprecation Summary
Claude Haiku 3 (claude-3-haiku-20240307) has already been retired — all requests now return an error. Migrate to Claude Haiku 4.5. Claude Sonnet 4 and Opus 4 retire June 15, 2026.
What to Watch For
Claude 5 is widely anticipated for Q2–Q3 2026 based on Anthropic’s release cadence, though Anthropic has made no official announcement. The advisor tool — which pairs a faster executor model with a higher-intelligence advisor model for long-horizon agentic workloads — launched in public beta and signals the architectural direction Anthropic is moving toward for complex, multi-step tasks.
The pace of Claude Code releases in particular has accelerated to near-daily — following Anthropic’s own disclosure that engineers internally use Claude for a growing share of their own development work.
The Claude Team plan’s usage limits changed significantly in May 2026. If you’re a Team subscriber and you haven’t noticed yet, you’re now getting substantially more capacity than you were in April — and the free tier got left behind entirely. Here’s exactly what changed, what you have now, and what it means in practice.
Updated May 9, 2026
Rate limits doubled for Team plan subscribers following Anthropic’s SpaceX Colossus 1 compute deal (announced May 6, 2026). Free plan excluded from all increases. This page reflects current limits.
What Changed in May 2026: The SpaceX Rate Limit Increase
On May 6, 2026, Anthropic announced a compute partnership with SpaceX, giving it access to SpaceX’s Colossus 1 data center. The practical result for paying subscribers came fast: rate limits doubled. Here’s the breakdown by tier:
Claude Code Pro and Max: 5-hour rate limits doubled
Team plan (all seats): 5-hour rate limits doubled
Seat-based Enterprise: 5-hour rate limits doubled
Tier 1 API customers: Max input tokens per minute increased 1,500%; max output tokens per minute increased 900%
Peak-hours throttling: Eliminated entirely for Pro and Max subscribers
Free plan: No change. Explicitly excluded from all increases.
The 1,500% input token figure for Tier 1 API is the one that didn’t get much press coverage. That’s a 15× ceiling increase for API users who’ve been running agent pipelines and hitting hard walls. If you’ve been rate-limited during multi-step Claude Code runs, this is the change that matters most.
Team Plan Seat Structure (Still Current)
The seat types haven’t changed — just the capacity within them. The Team plan still offers two seat types that can be mixed within the same organization:
Seat Type
Annual Price
Monthly Price
Usage vs Pro
Claude Code
Standard
$25/seat/month
$30/seat/month
1.25× more per session
No
Premium
$100/seat/month
$125/seat/month
6.25× more per session
Yes
Both seat types benefit from the May 2026 doubling of the 5-hour rate limit window. A Premium seat’s 6.25× multiplier now applies to a higher baseline than it did before May 6.
How the 5-Hour Rate Limit Window Works
Anthropic uses a rolling 5-hour window for usage limits, not a daily reset. Here’s what that means practically:
Usage is measured across a rolling 5-hour window, not midnight-to-midnight
If you hit the limit, you wait for the oldest usage to roll off — not for a fixed reset time
Heavy burst usage depletes your window faster than spread-out usage
The May 2026 doubling means the ceiling within that window is now twice as high
Peak-hours throttling — the extra restriction that kicked in during high-demand periods — is now eliminated for Pro and Max. Team plan benefits from the doubled limit floor; the throttling elimination is Pro and Max specific.
Deprecation notice: Claude Sonnet 4 and Opus 4 (original 4.0-generation, 20250514 date-string model IDs) are being retired June 15, 2026. Update any API integrations before that date.
What the Free Plan Doesn’t Get
The May 2026 rate limit increase does not apply to free accounts. Anthropic explicitly excluded the free tier from all capacity increases tied to the SpaceX deal. Paid plans now have a substantially higher ceiling while the free ceiling stays the same. If you’re hitting limits regularly on the free tier, the May 2026 changes are pressure toward upgrading — not relief.
Team Plan vs Pro: Which Limit Structure Fits You?
Individual power user: Pro ($20/month) with throttling eliminated is a strong option.
Team with Claude Code needs: Team Premium seats ($100/seat/month annually) give Claude Code access, 6.25× multiplier, and the doubled 5-hour window.
Team without Claude Code needs: Standard Team seats ($25/seat/month annually) for shared access at higher limits than individual Pro.
Frequently Asked Questions
Did the Team plan rate limits actually double in May 2026?
Yes. Anthropic confirmed the 5-hour rate limit doubled for Team plan subscribers following the SpaceX Colossus 1 compute deal announced May 6, 2026. This applies to both Standard and Premium seats.
Does peak-hours throttling elimination apply to Team plan?
The peak-hours throttling elimination was announced specifically for Pro and Max subscribers. Team plan benefits from the doubled rate limit floor; throttling elimination was not announced for Team.
What happens when I hit a Team plan usage limit?
Claude notifies you that you’ve reached your usage limit. With the 5-hour rolling window, you can continue once older usage rolls off — you’re not waiting for a midnight reset. Burst usage depletes the window faster than spread usage over the same period.
Are Claude Sonnet 4 and Opus 4 still available on Team?
They remain available but retire June 15, 2026. After that date, the active lineup is Opus 4.7, Sonnet 4.6, and Haiku 4.5.
Does the 1,500% Tier 1 API increase apply to Team plan API usage?
The 1,500% input and 900% output token increases apply to Tier 1 API customers specifically. Team plan through claude.ai uses the doubled 5-hour window. Both benefits apply in their respective contexts if you’re a Tier 1 API customer and a Team subscriber.
Is the free plan getting any rate limit improvements?
No. The free plan was explicitly excluded from all rate limit increases in the May 2026 SpaceX announcement.
Anthropic’s Claude pricing covers six tiers — Free, Pro, Max 5x, Max 20x, Team, and Enterprise — plus a separate pay-per-token API. Choosing the wrong path can cost you significantly more than necessary. Here’s what each option actually includes in 2026.
What Are Claude’s Subscription Plans and Prices?
Claude offers six tiers: Free ($0), Pro ($20/month), Max 5x ($100/month), Max 20x ($200/month), Team (from $20/seat/month billed annually), and Enterprise (custom pricing).
The Free plan gives you access to Claude on web, iOS, Android, and desktop with no credit card required, subject to rolling usage limits.
The Free plan gives you access to Claude on web, iOS, Android, and desktop with no credit card required. It includes text, image, and code generation plus web search. Usage limits are intentionally opaque — Anthropic doesn’t publish exact message caps — but limits reset on a rolling 5-hour window. The Free tier is designed for exploration, not sustained daily work.
Is Claude Pro Worth $20 a Month?
Pro delivers substantially more usage than Free, plus Claude Code, unlimited projects, the Research feature, and Google Workspace integration — sufficient for most individual developers and writers.
Pro delivers substantially more usage than Free, Claude Code in the terminal, unlimited projects, the Research feature, file creation, code execution, and Google Workspace integration. Usage still has limits — Anthropic does not publish exact message counts, but heavy sessions will reach the ceiling — but it’s sufficient for most individual developers and writers. Annual billing brings the effective rate to $17/month.
What Is the Difference Between Claude Max 5x and Max 20x?
Max 5x ($100/month) gives you 5x Pro’s per-session usage; Max 20x ($200/month) gives you 20x — enough that rate limits stop being a practical concern for full-day development work.
Max 5x provides 5x Pro’s per-session headroom at $100/month. Max 20x at $200/month delivers 20x Pro usage — enough that rate limits stop being a practical concern for most full-day development work. Both tiers include Claude Code, with access to Claude Opus 4.8 and Sonnet 4.6, and a 1M token context window.
Extra usage is available on Pro, Max 5x, and Max 20x — when you hit your included limit, you can continue at standard API-rate billing with a spending cap you set.
How Does Claude Team Plan Pricing Work?
Team requires a minimum of 5 seats: Standard seats at $20/seat/month billed annually ($25 monthly) include collaboration features but not Claude Code; Premium seats at $100/seat/month billed annually ($125 monthly) add Claude Code for developers.
Team requires a minimum of 5 seats and comes in two flavors. Standard seats at $20/seat/month billed annually ($25 billed monthly) include 1.25x more usage per session than Pro with a weekly reset, plus collaboration features, central billing, SSO, and Microsoft 365 and Slack integrations. Standard seats do not include Claude Code.
Premium seats at $100/seat/month billed annually ($125 monthly) add Claude Code, making them the right choice for engineering team members. You can mix Standard and Premium seats within one Team plan — so non-technical staff get Standard while developers get Premium.
Enterprise Plan — Custom Pricing
Enterprise is for organizations with compliance, data residency, or governance requirements. It includes access to the full 1M token context window, HIPAA readiness, SAML SSO, domain capture, spend controls, and dedicated support. Based on user reports, pricing starts around $60/seat with a 70-seat minimum, putting the floor near $50,000 annually — contact Anthropic sales for exact figures. Training on customer data is disabled contractually at this tier.
How Much Does the Claude API Cost Per Token?
As of May 2026: Claude Sonnet 4.6 costs $3.00 input / $15.00 output per million tokens; Opus 4.6 costs $5.00 / $25.00; Haiku 4.5 costs $1.00 / $5.00.
The API is entirely separate from subscription plans. You pay per million tokens (MTok) with no monthly minimum. Current rates as of June 10, 2026 (verified June 10, 2026 from Anthropic’s official models page):
Claude Opus 4.8: $5.00 input / $25.00 output per MTok
Claude Sonnet 4.6: $3.00 input / $15.00 output per MTok
Claude Haiku 4.5: $1.00 input / $5.00 output per MTok
Prompt caching cuts input costs by up to 90% for repeated context. The Batch API processes requests within 24 hours at a flat 50% discount on all tokens — ideal for content pipelines, data enrichment, and any workload where real-time responses aren’t required. As of March 2026, Anthropic eliminated long-context surcharges, so a 900K-token request costs the same per-token rate as a 9K one.
June 2026 — Professional Services Pricing
Managed Agents
Token rates + $0.08/session-hour active runtime. No surcharge for Orchestration or Outcomes (public beta).
Claude Security Beta
Included in Enterprise during beta. Powered by Opus 4.8 ($5/$25 per MTok at API rates).
Start with Pro for individual use, move to Max 5x if you regularly hit limits, choose Max 20x for full-day heavy use, and use Team for groups of 5+ where Standard seats cover non-technical staff and Premium covers developers.
Start with Pro if you’re an individual who hits Free limits regularly. Move to Max 5x if you’re a developer doing focused coding sessions. Max 20x makes sense if Claude is your primary tool throughout the workday. For teams, buy Standard seats for non-technical staff and Premium seats for developers who need Claude Code. If you’re building an application or automation that calls Claude programmatically, use the API — subscription plans don’t provide API credits and don’t reduce API costs.
Claude API Pricing: Pay-Per-Token Rates for Every Model
The Claude API is priced separately from claude.ai subscriptions. You pay per million tokens (MTok) consumed — input and output priced separately. There is no monthly minimum; you add credits and they deplete as you use the API.
Prompt caching reduces costs significantly for repeated context: cache write is 25% of base input price, cache read is 10%. The Batch API offers 50% off all models for non-time-sensitive work. For a full breakdown of how to minimize token spend, see Claude on a Budget: the Complete Guide.
How Does Claude Pricing Compare to GPT-4o and Gemini 2.0?
Claude Sonnet 4.6 sits above GPT-4o on price but competes at or above it on reasoning tasks. Claude Haiku 4.5 is the cost-competitive option for high-volume pipelines. Gemini 2.0 Flash is significantly cheaper for commodity tasks; the trade-off is reasoning depth and context handling on complex documents.
How Much Does a Claude License Cost for Business?
A Claude business license is sold per seat: Team Standard seats cost $20/seat/month billed annually ($25 monthly), Team Premium seats with Claude Code cost $100/seat/month billed annually ($125 monthly), with a 5-seat minimum. Enterprise licenses are custom-priced annual contracts.
License type
Annual billing
Monthly billing
Minimum seats
Claude Code
Team Standard seat
$20/seat/month
$25/seat/month
5
No
Team Premium seat
$100/seat/month
$125/seat/month
5
Yes
Enterprise license
Custom (annual contract — contact sales)
~70 (reported)
Yes
If you’re writing a budget request or procurement document, here are the numbers that matter: a 10-person team with 7 Standard and 3 Premium seats runs $440/month on annual billing — $5,280/year. Licenses are managed centrally with consolidated billing, SSO, and admin controls, and you can mix Standard and Premium seats within one plan. A Claude license covers the claude.ai apps and (on Premium seats) Claude Code; it does not include API credits, which are billed separately per token. There is no perpetual or one-time license option — all Claude licensing is subscription-based.
How Much Does Claude Code Cost?
Claude Code has no standalone price — it’s included with Pro ($20/month), Max 5x ($100/month), Max 20x ($200/month), Team Premium seats ($100/seat/month annual), and Enterprise. Alternatively, run it against an API key and pay per token.
Plan
Claude Code included?
Usage headroom
Free
No
—
Pro ($20/mo)
Yes
Standard Pro limits — enough for an hour or two of daily coding
Max 5x ($100/mo)
Yes
5x Pro — sustained daily development
Max 20x ($200/mo)
Yes
20x Pro — full-day heavy use and parallel sessions
Team Standard
No
—
Team Premium ($100/seat annual)
Yes
Per-seat developer allocation
Enterprise
Yes (Premium seats)
Custom
API key (pay-per-token)
Yes
No plan limits — billed at standard model token rates
For automation — cron jobs, CI pipelines, claude -p scripts — note the June 15, 2026 change: subscription plans get a monthly Agent SDK credit pool (Pro $20, Max 5x $100, Max 20x $200, Team Standard $20/seat, Team Premium $100/seat), with overage billed at API rates. Full details in the Agent SDK dual-bucket billing guide. For the complete tier-by-tier breakdown including API-key economics, see the full Claude Code pricing guide.
What Are Claude’s Usage Limits and Extra Usage Costs?
Every Claude plan has usage limits that reset on a rolling 5-hour window, plus weekly caps on paid tiers. When you hit a paid plan’s limit, you can either wait for the reset or buy extra usage at standard API token rates with a spending cap you control.
Plan
Relative usage
Reset window
Extra usage available?
Free
Baseline (light use)
Rolling 5 hours
No — upgrade required
Pro
~5x Free
Rolling 5 hours + weekly cap
Yes — API rates, capped by you
Max 5x
5x Pro
Rolling 5 hours + weekly cap
Yes
Max 20x
20x Pro
Rolling 5 hours + weekly cap
Yes
Team Standard
1.25x Pro per seat
Weekly reset
Yes (admin-controlled)
Team Premium
Higher, includes Claude Code
Weekly reset
Yes (admin-controlled)
Anthropic intentionally doesn’t publish exact message counts — limits are measured in compute, so long conversations, large file uploads, and Opus-heavy sessions consume your window much faster than short Haiku chats. For the full mechanics, see Claude Team plan usage limits and Claude API rate limits.
Claude Pricing by Country: UK, Australia, India, and Canada
Anthropic charges the same USD list price in every country — Claude Pro is $20/month worldwide. Your bank converts to local currency, and applicable local tax (VAT or GST) is added at checkout.
Country
Claude Pro (approx. local)
Claude Max 5x (approx. local)
Tax added at checkout
United Kingdom
≈ £16/month
≈ £79/month
20% VAT
Australia
≈ A$31/month
≈ A$153/month
10% GST
India
≈ ₹1,700/month
≈ ₹8,600/month
18% GST
Canada
≈ C$27/month
≈ C$137/month
GST/HST (5–15% by province)
New Zealand
≈ NZ$33/month
≈ NZ$166/month
15% GST
Local-currency figures are approximate conversions at June 2026 exchange rates — your card statement reflects your bank’s rate plus any foreign-transaction fee. There is no region-specific discount pricing for claude.ai plans, and API token rates are likewise USD-denominated everywhere. Prices shown on Anthropic’s pricing page exclude applicable tax.
Frequently Asked Questions: Claude Pricing
How much does Claude cost per month?
Claude costs $0 (Free), $20/month (Pro), $100/month (Max 5x), or $200/month (Max 20x) for individual plans. Team plans start at $20/seat/month (annual billing, 5-seat minimum). API access is pay-per-token with no monthly minimum.
Is there a free version of Claude?
Yes. The Free plan gives access to Claude on web, iOS, Android, and desktop with no credit card required. Usage limits apply and reset on a rolling 5-hour window. The Free tier is suitable for light, exploratory use but not sustained daily work.
What does Claude Pro include at $20/month?
Pro includes approximately 5x the usage of Free, Claude Code in the terminal, unlimited projects, the Research feature, file creation, code execution, and Google Workspace integration. Annual billing brings the effective rate to $17/month.
What is the cheapest way to use Claude?
The Free plan is the cheapest at $0. For API access, Claude Haiku 4.5 at $1 input / $5 output per MTok is the most cost-efficient model. Combined with the Batch API (50% discount) and prompt caching, high-volume workflows can run at a fraction of standard API cost.
What is Claude Max and is it worth $100–$200 per month?
Claude Max comes in two tiers: Max 5x at $100/month gives 5x Pro’s per-session usage, and Max 20x at $200/month gives 20x. Max is worth it if you’re hitting Pro limits regularly during development or coding sessions. Both include Claude Code and the full 1M token context window with Claude Opus 4.8 and Sonnet 4.6.
How does Claude Team pricing work?
Team plans require a minimum of 5 seats. Standard seats cost $20/seat/month billed annually ($25 monthly) and include collaboration features. Premium seats cost $100/seat/month billed annually ($125 monthly) and add Claude Code — the right choice for developers on the team. You can mix Standard and Premium seats within the same Team plan.
Does Claude Pro give you access to Claude Opus 4.8?
Pro gives you access to Claude’s models including Opus 4.8 for complex tasks, Sonnet 4.6, and Haiku 4.5, subject to usage limits. The Max tiers give you significantly more headroom to use Opus 4.8 for extended sessions. For unlimited, predictable API access to Opus 4.8, use the API directly at $5 input / $25 output per million tokens.
What is the Claude API cost per million tokens in 2026?
As of June 2026 (verified from Anthropic’s official docs): Claude Opus 4.8 costs $5.00 input / $25.00 output per million tokens; Claude Sonnet 4.6 costs $3.00 input / $15.00 output; Claude Haiku 4.5 costs $1.00 input / $5.00 output. The Batch API offers 50% off all models for non-real-time work.
Does Claude have a student discount?
There is no individual self-serve student discount, but Anthropic now offers an Education plan with discounted rates for universities and their members — check whether your institution participates. Otherwise students can use the Free tier without a credit card, and the cheapest paid path is Pro at $17/month with annual billing.
Can I use Claude without a subscription by paying per use?
Not directly through claude.ai — the website only offers Free, Pro, Max, and Team subscription plans. Pay-per-use access is available only through the Claude API, which requires a developer account. API pricing starts at $1 input / $5 output per million tokens for Haiku 4.5 with no monthly minimum charge.
How much does the Anthropic Console (Claude Console) cost?
The Anthropic Console itself is free — it’s the developer dashboard for managing API keys, tracking usage, and testing prompts in the Workbench. You only pay for the API tokens you consume, starting at $1 input / $5 output per million tokens for Haiku 4.5. You add prepaid credits to get started; there is no monthly platform fee.
How much is a Claude license for business?
Claude business licensing is per-seat: Team Standard seats cost $20/seat/month billed annually ($25 monthly), and Team Premium seats with Claude Code cost $100/seat/month billed annually ($125 monthly), with a 5-seat minimum. Enterprise licenses are custom annual contracts. There is no perpetual license — all Claude licensing is subscription-based.
Does the Claude desktop app cost extra?
No. The Claude desktop app for Windows and macOS is included with every plan, including Free. Desktop, web, and mobile all share the same account and the same usage limits — there is no separate desktop pricing.
Is Claude cheaper in India, the UK, or Australia?
No — Anthropic charges the same USD list price worldwide. Claude Pro is $20/month everywhere; your bank converts it to local currency (roughly £16, A$31, or ₹1,700) and local VAT or GST is added at checkout where applicable. There is no regional discount pricing.
Is Claude available on Azure, AWS, or Google Cloud?
Yes. Claude models are available through Amazon Bedrock and the Claude Platform on AWS, Google Cloud’s Vertex AI, and Microsoft Foundry. Cloud-platform pricing is token-based and aligned with Anthropic’s API rates, billed through your existing cloud account — useful if your organization has cloud spend commitments to draw down.
Does Anthropic offer nonprofit pricing?
Anthropic doesn’t list a standing nonprofit discount on its pricing page as of June 2026. Nonprofits typically start with Team at standard rates or contact Anthropic sales about Enterprise terms. An Education plan with discounted rates does exist for universities and their members.
May 2026: Managed Agents & Claude Security Pricing
Updated June 10, 2026
Anthropic’s professional services now include Managed Agents and Claude Security. Pricing for both is API-based, not subscription-based.
Claude Managed Agents Pricing
Managed Agents pricing follows the standard API token rates for whichever Claude model you use inside the agent pipeline — there’s no separate Managed Agents surcharge on top of model costs. You pay for the tokens the models consume:
The Dreaming advisor tool uses a short-plan generation (typically 400–700 tokens) at the advisor model’s rate, while the executor handles full output at its lower rate — keeping combined cost well below running the advisor model end-to-end. Use max_uses to cap advisor calls per request. Requires beta header: anthropic-beta: advisor-tool-2026-03-01. Docs: platform.claude.com/docs/en/managed-agents/dreams
Claude Security Beta Pricing
Claude Security is currently in public beta for Enterprise customers. Anthropic has not published a standalone per-scan or per-seat price for Claude Security Beta — access is included as part of Enterprise during the beta period. Underlying model is Claude Opus 4.8 ($5 input / $25 output per million tokens at API rates). For Enterprise pricing including Claude Security, contact Anthropic sales.
Claude Mythos Preview Pricing (Project Glasswing)
Claude Mythos Preview is not available via standard API or any subscription tier. Through Project Glasswing (invitation-only, defensive cybersecurity workflows): $25 per million input tokens, $125 per million output tokens. No self-serve access — contact Anthropic for Glasswing information at anthropic.com/glasswing.
What to do next
Now that you have the price — here’s how to actually run it
Knowing the cost is step one. The harder questions are whether Managed Agents is the right architecture for your use case, how it compares to building on the raw API, and what a realistic monthly bill looks like at scale.
Use this tool to figure out which Claude plan actually fits your usage, what you’d pay on the API equivalent, and how the new June 15, 2026 Agent SDK billing change affects your costs. All rates verified against Anthropic’s official pricing documentation as of June 10, 2026.
Tell us how you use Claude
2 = roughly 30 hours of normal Claude use per month
Output is typically ~25% of input for chat work
$ value of unattended Claude work (cron jobs, scripts, GitHub Actions). 0 if you only chat.
Your estimated costs
Email me this breakdown
Get your numbers in your inbox so you can compare plans later — or forward them to whoever approves the budget.
This calculator uses Anthropic’s published API rates as of June 10, 2026. Subscription pricing reflects current public plans. The Agent SDK monthly credit pool launches June 15, 2026 — Pro $20, Max 5x $100, Max 20x $200, Team Standard $20/seat, Team Premium $100/seat.
What Claude Actually Costs: Six Worked Examples (June 2026)
The calculator above is interactive; these are the same calculations worked through for six common usage profiles, using Anthropic’s published rates as of June 10, 2026. API-equivalent figures assume standard rates with no prompt caching or batch discounts.
Profile
Monthly usage
Best plan
Plan cost
API equivalent
Casual user — questions a few times a week
0.5M in / 0.13M out (Sonnet 4.6)
Free, or Pro for headroom
$0–$20
≈ $3.45/mo
Individual writer or analyst — daily use
2M in / 0.5M out (Opus 4.8)
Pro
$20 ($17 annual)
≈ $22.50/mo
Developer — focused daily coding with Claude Code
10M in / 2.5M out (Opus 4.8)
Max 5x
$100
≈ $112.50/mo
Power user — Claude open all day, parallel sessions
30M in / 7.5M out (Opus 4.8)
Max 20x
$200
≈ $337.50/mo
5-person team — 3 non-technical, 2 developers
Mixed
Team: 3 Standard + 2 Premium
$260/mo (annual billing)
Varies by usage
High-volume pipeline — classification or enrichment
50M in / 10M out (Haiku 4.5, Batch API)
API direct
—
≈ $50/mo (after 50% batch discount)
The pattern: subscriptions beat the API whenever usage is steady and interactive — Pro pays for itself at roughly 2M input tokens a month on Opus 4.8. The API wins for spiky automated workloads, anything that can use the Batch API, and pipelines that run on Haiku 4.5. A reasonable rule of thumb: if your monthly API equivalent lands more than about 50% above a subscription price, take the subscription.
Next Steps: What to Read After This
You came here for pricing. Depending on what you actually need to do next, these are the right places to go:
