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

By TwitterAPI.io Team•15 min read
Claude Code pricing map: Free with no Claude Code, Pro $20, Max $100 and Ultra $200 monthly plans, and API pay-as-you-go token prices for Haiku 5.5, Sonnet 5.5, Opus 5.5 and Fable 5.1.
Claude Code pricing at a glance: subscriptions with usage limits versus per-token API billing.

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.

01 — Section

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.

PlanPriceUsage vs ProExtras that matter for coding
Free$0LimitedNo Claude Code
Pro$20/mo, or $17/mo billed yearly1x (5-hour and weekly)Claude Code, Opus and Sonnet, usage credits
Max$100/mo5x every 5 hours and every weekFable up to half the weekly limit, $100 in monthly API credits, priority access
Ultra$200 monthly10x weekly, no 5-hour limit (verified accounts)Fable up to half the weekly limit, $200 in monthly API credits, priority access

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.

02 — Section

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.

SeatBilled yearlyBilled monthlyUsage
Team standard$20 per seat/mo$25 per seat/moMore than Pro
Team premium$100 per seat/mo$125 per seat/mo5x a standard seat
Enterprise$20 per seat/mo + usage at API ratesAnnual onlyScales with model and task

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.

03 — Section

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.

04 — Section

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):

ModelInputOutputCache read
Haiku 5.5 (prompts up to 100K tokens)$0.10$0.50$0.01
Sonnet 5.5$2$10$0.10
Opus 5.5$4$20$0.20
Fable 5.1$10$50$0.25

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.

05 — Section

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.

Monthly cost (30 days)Poll every 60 sPoll every 5 min
X data via TwitterAPI.io$7.95$4.85
+ Haiku 5.5 triage (estimate)$2.04 = $9.99 total$1.48 = $6.33 total
+ Sonnet 5.5 triage (estimate)$40.8 = $48.75 total$29.68 = $34.53 total
+ Opus 5.5 triage (estimate)$81.6 = $89.55 total$59.37 = $64.22 total

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.

Bar chart of the monthly cost of an always-on X keyword monitor: Haiku 5.5 $9.99 at 60-second polls and $6.33 at 5-minute polls, Sonnet 5.5 $48.75 and $34.53, Opus 5.5 $89.55 and $64.22, with blue X data and orange model token segments and dashed lines for Pro $20 and Max $100.
Monthly cost of an always-on X keyword monitor that triages every match with Claude: measured post volume (collected in 2026), Anthropic list prices, token counts estimated as characters / 4.
06 — Section

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.

Rate cardPrice per 1,000 posts readMonthly cap
Official X API pay-per-usage (docs.x.com)$5.00 ($0.005 per post)3 million post reads, Enterprise above
TwitterAPI.io$0.15 (15 credits per tweet)No cap; rate limit by tier

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.

07 — Section

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.

AccountPosts per dayMention Claude CodeMention plans, pricing, usage or limitsMedian views: plan posts vs all
@claudeai0.4727.6%28.6%4.2M vs 2.1M
@AnthropicAI0.544.5%9.0%0.6M vs 0.8M

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.

Two bar charts. Left: 27.6% of @claudeai posts mention Claude Code and 28.6% mention plans, pricing, usage or limits, against 4.5% and 9.0% on @AnthropicAI. Right: median views per post, 2.1M for all @claudeai posts versus 4.2M for its plan and limit posts, and 0.8M versus 0.6M on @AnthropicAI.
Latest ~200 timeline posts per official account, reposts excluded, collected in 2026. Topic by keyword match on post text.
08 — Section

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.

bash
# 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 mode
09 — Section

How 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.

python
"""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()
10 — Questions

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.

11 — Further reading

Continue

Sources & further reading
More from this series
Build it

Stop reading. Start building.

Starter credits cover real testing on real data. Google sign-in, no card, no application queue.

Get an API key

Already building with TwitterAPI.io? Publish an honest tutorial or build log about it and earn up to $200 a month in API credits.