Claude Code Pricing in 2026: Plans, Usage Limits and the Real Cost of an Always-On Agent

This page is about paying for Claude Code, Anthropic's coding agent: which subscription includes it, how its usage limits work, and when an API key is the better deal. If you need per-token prices for calling the Claude API from your own code (batch discounts, prompt caching, a per-model rate table), read our Claude API pricing guide instead; that page covers the API rate card, this one covers plans.
Every plan price and limit below was read from claude.com/pricing and the Claude Code docs at code.claude.com for this build, and Anthropic has changed plan names recently: on October 30, 2026 the @claudeai account announced that Max 5x is now simply Max and Max 20x is now Ultra, at the same $100 and $200 prices. Many third-party pricing guides still use the old names.
We also measured something the plan cards cannot tell you: what an unattended Claude Code agent that watches X (Twitter) actually has to chew through. We collected 599 live posts matching "claude code" plus a cost word, and the latest posts of @claudeai and @AnthropicAI, in 2026, and priced the workload both ways.
Is Claude Code free? Plans compared: Pro, Max, Ultra
No. On the plan comparison at claude.com/pricing, the Claude Code row reads No for Free and Yes for Pro, Max and Ultra. The Free plan gives you chat on web, desktop and mobile with limited usage every 5 hours and every week, but not the coding agent.
There are two ways to get Claude Code running. A paid Claude plan: you log in with your claude.ai account (/login), and usage comes out of the plan's limits. A Claude Console account: you create an API key, set ANTHROPIC_API_KEY, and every token is billed at API rates. The authentication docs at code.claude.com/docs/en/authentication list both, plus cloud providers such as Amazon Bedrock, Google Cloud and Microsoft Foundry for organizations that already buy Claude there.
Either way you are paying for model usage, and that matters later, because the same claude binary can be billed in completely different ways depending on which credential it finds first.
These are the individual plans as listed on claude.com/pricing. Prices exclude tax; Anthropic notes that prices and plans can change at its discretion.
Pro is the entry point and the only individual plan with an annual option ($200 billed up front). Max and Ultra are billed monthly only. The new detail on both higher tiers is a monthly allowance of API credits for building on the Claude Platform, which means a Max or Ultra subscriber gets some pay-as-you-go budget for their own scripts on top of the interactive allowance.
The plan names changed recently. The @claudeai post announcing the rename (Max 5x to Max, Max 20x to Ultra, and the removal of the 5-hour limit for verified Ultra accounts) drew 6,219,596 views in our sample, 2.9x the account's median. Newer Ultra accounts keep a temporary 5-hour limit until they are verified, according to the same post.
Which plan for Claude Code? Anthropic does not publish a message or token count per plan; the pricing FAQ says how fast you reach a limit depends on the model, the length of your conversations and the size of your files. A practical rule from the plan structure: Pro suits a few focused sessions a day, Max suits all-day use, and Ultra is the plan that removes the 5-hour ceiling for long unattended runs.
Team and Enterprise pricing for Claude Code
Teams of 2 to 150 people buy the Team plan, which mixes two seat types. Both include Claude Code and Claude Cowork, central billing, single sign-on and no model training on your content by default.
The Team plan also lists up to $500 a month in pooled API credits. Enterprise works differently from every other plan: the seat fee buys access and admin features (SCIM, audit logs, role-based access, custom data retention, spend limits), and usage is billed at API rates on top, with a 20-seat minimum. So for an Enterprise rollout the useful planning number is token spend, not the seat price.
Anthropic gives that planning number in the Claude Code cost docs: across enterprise deployments, the average is about $13 per developer per active day and $150 to $250 per developer per month, with 90% of users staying under $30 per active day. The docs recommend starting with a small pilot group to set a baseline.
How Claude Code usage limits work
Subscriptions do not meter dollars; they meter usage against two windows. The pricing FAQ describes a limit that resets on a rolling five-hour session window, with weekly limits on top for paid plans. Pro gives at least 5x the usage per 5-hour session of Free, Max gives 5x Pro, and Ultra gives 10x Pro per week with no 5-hour window for verified accounts.
One pool for everything. The FAQ is explicit that activity across Claude on web, desktop, mobile and Claude Code all draws from the same pool. A long chat in the morning leaves less room for a coding session in the afternoon.
What happens at the limit. You can wait for the reset, move to a higher plan, or, on paid plans, turn on usage credits, which keep you working at standard API rates. Anthropic also reserves the right to apply other caps (weekly, monthly, per model or per feature) to keep access fair.
Temporary changes happen. The official accounts announce limit changes on X: in our @claudeai sample, Claude Code weekly limits were raised 50% for a period in spring 2026, extended once in July, and a May 2026 compute partnership was tied to higher usage limits for Claude Code and the API. Treat any fixed number you read in a guide, including this one, as something to re-check in Settings > Usage.
Why usage climbs in long sessions. The cost docs explain that Claude Code sends the full conversation with every request; a one-line question in a session open all day still draws usage for the whole history (at the cached rate if the cache is warm). A first message after a break longer than the cache lifetime reprocesses everything. And a session-scoped scheduled task fires on its interval even while the session is idle, sending the full context each time. For an always-on agent, that last point is the one that bites.
Subscription or API key: which costs less?
With an API key, Claude Code charges per token at Anthropic's list prices. These are the current models on the API tab of claude.com/pricing (per million tokens, standard tier):
Batch processing saves 50%, fast mode for Opus 5.5 costs 2x standard, and US-only inference costs 1.1x. Haiku 5.5 costs more for prompts over 100K tokens ($0.50 input, $2.50 output). Our Claude API pricing page goes deeper on caching and batch math.
The break-even is about usage shape, not price. If Anthropic's enterprise average ($150 to $250 per developer per month at API rates) is roughly your pattern, Pro at $20 is far cheaper as long as you fit inside its limits, and Max or Ultra exist for people who do not. An API key wins when usage is spiky or tiny (a few dollars of tokens in a month), when you need a hard budget per run (--max-budget-usd in print mode), or when the work runs unattended in CI where a personal subscription login does not belong.
The credential trap. The authentication docs list a precedence order, and ANTHROPIC_API_KEY ranks above your subscription login from /login. In interactive mode Claude Code asks once whether to use the key; in non-interactive -p mode a present key is always used. So a stray ANTHROPIC_API_KEY in your shell profile silently moves scripted runs onto per-token billing even though you pay for Max. For scripts that should use a subscription, the docs describe claude setup-token, which creates a long-lived CLAUDE_CODE_OAUTH_TOKEN for CI pipelines and scripts.
Checking spend. /usage shows plan usage bars for subscribers and a session cost estimate for API users; the docs stress that the dollar figure is computed locally at list price and that the Usage page in the Claude Console is the authoritative bill.
What an always-on X monitoring agent costs: measured
Plan cards price interactive coding. Many people buying Claude Code want something else: an agent that runs all day, watches X for a topic, and reports only what matters. That workload has two meters: the X data it reads and the model tokens it spends judging it. We measured the first and estimated the second.
The workload. A live search for "claude code" plus a cost word (limit, pricing, usage, plan, subscription, Max, Pro) returned 599 posts over 13.5 hours: 44.4 posts an hour, about 1,064 a day, with a peak of 58 in one clock hour. 48.7% of 60-second polls would have found nothing; at 5-minute polls only 4.3% would.
The tokens. The posts had a median of 270 characters, which is about 68 tokens; the mean was 211.2 tokens because long posts pull it up (p90 480). Token counts here are an estimate (characters divided by 4). We assumed 400 tokens of instructions per triage batch and 30 output tokens per verdict.
What the numbers say. At API list prices, a Haiku-based monitor costs less than half of a Pro subscription, data included. A Sonnet-based monitor at 60-second polls ($48.75) costs more than Pro and less than Max. The polling interval mainly changes the input-token bill, because every non-empty poll repeats the instruction prompt: 15.61 million input tokens a month at 60 seconds against 10.05 million at 5 minutes, for the same 31,934 posts.
Why not just run it on the subscription? You can (Claude Code in print mode with a CLAUDE_CODE_OAUTH_TOKEN), but every call then draws from the same 5-hour and weekly pool as your interactive work, and the docs warn that scheduled tasks resend the full context on every fire. A stateless print-mode call per poll, with only the new posts as input, is the pattern that keeps either bill small.

The X data side: TwitterAPI.io vs the official X API
The data line in that table uses TwitterAPI.io's published prices: 15 credits per tweet returned, $0.15 per 1,000 tweets, with a 15-credit minimum per request, so a poll that finds nothing costs $0.00015 and a full 20-tweet page costs $0.003. You pay only for the data returned, and no X account is needed for reads.
That minimum sets a polling floor regardless of topic: checking every 60 seconds for a month is 43,200 checks, or $6.48 if every one came back empty; every 5 minutes it is $1.30. Our measured monitor sits above the floor because about half its 60-second polls returned posts.
On X's own pay-per-usage rate card (docs.x.com/x-api/getting-started/pricing) the same 31,934 posts a month would cost about $159.67 in post reads, roughly 33x the $0.15 per 1,000 rate. X also charges $0.010 per user read and offers $20 in credits on a first eligible card purchase plus a match of the first auto-recharge up to $50.
New TwitterAPI.io accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days). Before the first payment the rate limit is 0.2 requests per second, which is plenty for one monitor polling every 60 seconds; paid accounts get 20 requests per second. Purchased credits never expire.
What the official accounts post about plans and limits
Pricing news reaches users through X first, so we read the latest timeline posts of both official accounts (reposts excluded): 185 posts from @claudeai covering 390 days and 178 from @AnthropicAI covering 332 days.
Product news lives on @claudeai. More than a quarter of its posts mention Claude Code, against 4.5% on @AnthropicAI, and its posts about plans, prices and limits reach about twice the median views of its other posts. The limit-related posts were the outliers: the post extending higher Claude Code weekly limits drew 28,235,025 views, 13.3x the account median.
Practical takeaway. If you budget around a plan's limits, following @claudeai (or monitoring it with the script below) is how you learn about a temporary boost or a rename the day it happens, before the pricing guides catch up.

How to keep Claude Code costs down
Pick the model per job. The model aliases in Claude Code (haiku, sonnet, opus, fable) let you route cheap triage to Haiku and keep Opus for hard reasoning; in our monitor the model choice moved the monthly bill from about $6 to about $64 with identical data.
Keep context small. Because every request resends the conversation, /clear between unrelated tasks and a lean CLAUDE.md save more than any plan change. The /usage breakdown on paid plans attributes usage to skills, subagents and MCP servers and suggests fixes, such as trimming a large CLAUDE.md.
Cap unattended runs. In print mode, --max-turns limits agentic turns and --max-budget-usd stops a run once estimated API spend reaches a set amount (the docs note spend can pass the cap, so leave headroom).
Check which credential is active. If scripted runs should use your subscription, make sure ANTHROPIC_API_KEY is not set in that environment; if they should bill to the API, prefer a dedicated Console key with its own spend limit.
Do not poll faster than the topic moves. For the X side, 5-minute polls cut the data bill from $7.95 to $4.85 a month on our measured topic, and on a quiet topic the bill stays close to the polling floor.
# Stateless triage call: new posts on stdin, cheap model, hard caps (print mode)
cat new_posts.txt | claude -p "Mark each post KEEP or SKIP with a 10-word reason" \
--model haiku --max-turns 1 --max-budget-usd 0.50 --output-format text
# Scripts that should bill to your Pro/Max/Ultra plan: create a long-lived token once
claude setup-token # then export CLAUDE_CODE_OAUTH_TOKEN in the job environment
unset ANTHROPIC_API_KEY # a present API key wins over the subscription in -p modeHow we collected this
Question. What does an always-on Claude Code agent that watches X have to process each month, and what does that cost; and how do the official Anthropic accounts communicate plans and limits? Sources. Part A: a live /twitter/tweet/advanced_search for "claude code" plus a cost word, newest first, 599 posts from 528 distinct authors over 13.5 hours. Part B: /twitter/user/last_tweets for @claudeai and @AnthropicAI, about 200 posts each. Collected in 2026 through our rate-limited read client, 50 requests costing about $0.14 in credits.
Method. Polling windows were simulated over the covered span (60 s and 300 s). Tokens are an estimate (characters / 4), not tokenizer counts; Anthropic's tokenizer may count differently, and the triage prompt size (400 tokens) and output size (30 tokens per post) are our assumptions. Model costs use API list prices from claude.com/pricing, standard tier, no batch discount and no prompt caching. Topic labels on the official timelines are keyword matches on post text.
What the sample cannot show. 13.5 hours of one search is a snapshot: volume swings with news (a plan change can multiply it), weekends differ from weekdays, and a monitor on a different topic will see a different rate. Subscription costs for the same workload cannot be computed, because Anthropic does not publish per-plan token allowances. 74.0% of the sample was English; 29.4% were replies.
Privacy. Aggregates only. Search results come from private individuals, so raw pages stayed off the repository and only de-identified rows (hour, language, length, engagement counts) are kept. Only the two Anthropic organization accounts are named.
"""x_monitor_claude.py - an always-on X (Twitter) keyword monitor that hands each batch of new
posts to Claude Code in print mode for triage. Data: TwitterAPI.io (no X account needed).
Model: whatever `claude` is signed in with (a Pro/Max/Ultra login, or ANTHROPIC_API_KEY).
pip install requests ; export TWITTERAPI_IO_KEY=... ; run under cron, launchd or a loop.
"""
import json
import os
import subprocess
import time
import requests
BASE = "https://api.twitterapi.io"
HEADERS = {"X-API-Key": os.environ["TWITTERAPI_IO_KEY"]}
QUERY = '"claude code" (limit OR pricing OR usage OR plan) -filter:retweets'
STATE = "seen_ids.json"
INTERVAL_S = 300 # 5 minutes: measured 4.3% of 5-minute polls came back empty
def load_seen():
try:
return set(json.load(open(STATE)))
except (FileNotFoundError, ValueError):
return set()
def fetch_new(seen, since_unix, max_pages=5):
"""Newest-first search; stop at the first page that holds only posts we already saw."""
new, cursor = [], ""
for _ in range(max_pages):
params = {"query": f"{QUERY} since_time:{since_unix}", "queryType": "Latest", "cursor": cursor}
r = requests.get(f"{BASE}/twitter/tweet/advanced_search", headers=HEADERS, params=params, timeout=30)
if r.status_code == 429:
time.sleep(5)
continue
r.raise_for_status()
body = r.json()
page = [t for t in body.get("tweets", []) if t["id"] not in seen]
new += page
if not page or not body.get("has_next_page"):
break
cursor = body.get("next_cursor", "")
return new
def triage_with_claude(posts):
"""One Claude Code print-mode call per non-empty poll. haiku keeps the token bill small."""
lines = [
f"{t['createdAt']} | likes {t.get('likeCount', 0)} | views {t.get('viewCount', 0)} | {t['text'][:500]}"
for t in posts
]
prompt = (
"You triage X posts about Claude Code pricing and usage limits. "
"Reply with one line per post: KEEP or SKIP, then a 10-word reason. "
"KEEP only reports of plan changes, limit changes or billing surprises."
)
out = subprocess.run(
["claude", "-p", prompt, "--model", "haiku", "--max-turns", "1",
"--max-budget-usd", "0.50", "--output-format", "text"],
input="\n".join(lines), capture_output=True, text=True, timeout=300,
)
return out.stdout.strip()
def main():
seen = load_seen()
since = int(time.time()) - INTERVAL_S
while True:
started = int(time.time())
posts = fetch_new(seen, since)
if posts: # an empty poll costs the 15-credit minimum ($0.00015) and no tokens
print(triage_with_claude(posts), flush=True)
seen.update(t["id"] for t in posts)
json.dump(sorted(seen)[-5000:], open(STATE, "w"))
since = started - 30 # small overlap; the seen-ids set removes duplicates
time.sleep(INTERVAL_S)
if __name__ == "__main__":
main()
Questions readers ask
Is Claude Code free?
No. The Free Claude plan does not include Claude Code. You need Pro ($20 a month, or $17 a month billed yearly), Max ($100), Ultra ($200), a Team or Enterprise seat, or a Claude Console API key billed per token.
How much is Claude Code per month?
It depends on how you pay. Subscriptions are flat: Pro $20, Max $100, Ultra $200, billed monthly, for individuals; Team seats $25 or $125 billed monthly. With an API key you pay per token, and Anthropic's docs report an enterprise average of about $13 per developer per active day, or $150 to $250 per developer per month.
What are the Claude Code usage limits?
Plans reset on a rolling 5-hour window plus a weekly cap. Max gives 5x Pro usage in both windows; Ultra gives 10x Pro weekly usage and no 5-hour limit for verified accounts. Anthropic publishes no fixed message count, and Claude Code shares the pool with your Claude chats. Check where you stand in Settings > Usage or with /usage.
What happened to Max 5x and Max 20x?
On October 30, 2026 Anthropic renamed them: Max 5x is now Max ($100 a month) and Max 20x is now Ultra ($200 monthly). Prices stayed the same, and verified Ultra accounts lost the 5-hour limit. Weekly limits were unchanged, according to the @claudeai announcement.
Is Claude Code cheaper with an API key or a subscription?
For daily interactive use, a subscription is usually cheaper as long as you fit inside its limits, since API-rate usage averages $150 to $250 per developer per month in Anthropic's enterprise data. An API key is cheaper for light or spiky use and is the cleaner choice for unattended jobs with a hard budget.
Why is Claude Code charging my API account when I pay for Max?
Probably because ANTHROPIC_API_KEY is set. In Claude Code's authentication order the API key ranks above your subscription login, and in non-interactive -p mode a present key is always used. Unset it, or toggle the custom API key off in /config for interactive sessions.
What happens when I hit my Claude Code limit?
You can wait for the 5-hour or weekly window to reset, upgrade to a higher plan, or, on paid plans, turn on usage credits, which bill further usage at standard API rates. Pro, Max and Ultra users can set a monthly spend limit for usage credits.
How much does it cost to run a Claude agent that monitors X (Twitter)?
In our measurement, a keyword monitor that saw 1,064 posts a day cost about $6.33 a month on Haiku 5.5 or $34.53 on Sonnet 5.5 with 5-minute polls, including $4.85 of X data at $0.15 per 1,000 tweets. Token costs are an estimate at API list prices.
Continue
- Claude plans and pricing (Free, Pro, Max, Ultra, Team, Enterprise, API rates)
- Claude Code docs: Manage costs effectively (enterprise averages, /usage, background token usage)
- Claude Code docs: Authentication methods and credential precedence
- Claude Code docs: CLI reference (-p, --model, --max-turns, --max-budget-usd)
- X API pricing: pay-per-usage rate card
- TwitterAPI.io docs: per-call pricing and endpoints
- X (Twitter) API hub: endpoints, access and pricing
- Claude API pricing per model, with batch and caching discounts
- How to connect Claude to Twitter data through MCP
- Claude Code channels: push X events into a session
- Claude Code routines for scheduled X checks
- X API cost breakdown for 2026
- Twitter API cost per request, compared
- TwitterAPI.io pricing and credit plans
- 01Twitter (X) API License: The Developer Agreement in Plain English
- 02Claude Agent SDK: Build a Twitter (X) Research Agent in Python
- 03OpenRouter API: Base URL, API Key, Free Models and Pricing, Plus a Twitter (X) Agent That Swaps Models
- 04Codex vs Claude Code: Setup, MCP, Headless Runs and Pricing Compared for Twitter (X) Data Agents
- 05Open AI API Key: How to Get One, Pay for It, Keep It Safe and Feed It Live Twitter (X) Data
- 06Claude API Pricing in 2026: Per-Token Rates and What 1,000 Tweets Really Cost
- 07Claude Code Channels: Telegram, Discord and Twitter (X) Alerts in Your Session
- 08OpenClaw vs Claude Code: which agent should run your Twitter (X) jobs?
Stop reading. Start building.
Starter credits cover real testing on real data. Google sign-in, no card, no application queue.
Get an API keyAlready building with TwitterAPI.io? Publish an honest tutorial or build log about it and earn up to $200 a month in API credits.