Claude Extra Usage Cost: What Usage Credits Really Cost in Claude Code (and How to Cap Them)

Short answer: Claude extra usage cost is the standard Claude API price, charged per token, on top of your Pro, Max or Ultra subscription. Anthropic now calls the feature “usage credits.” It starts after you use up a 5-hour or weekly limit and keeps billing until you reach your monthly spend limit or your prepaid balance runs out. For a coding agent that’s roughly $4 an hour on Sonnet 5.5, $8 on Opus 5.5 and $17 on Fable 5.1 with the assumptions below. Below: per-token prices, an estimator script, the settings that cap it, and the fix for “Credit balance is too low.”

Last updated: November 2, 2026. Prices come from Anthropic’s API pricing page, the Claude Help Center articles on usage credits and usage bundles, and the Claude Code docs (costs, authentication, model configuration, error reference). I also read recent threads on r/ClaudeCode and GitHub issues in anthropics/claude-code. Disclosure: I don’t have a Claude subscription, and nothing here comes from my own Claude Code sessions or a Claude bill. Every Claude dollar figure is calculated from Anthropic’s published prices. The scripts were run on a Linux box with sample inputs, and the output is shown.

“Extra usage” vs “usage credits”: same feature, new name

Search for “Claude extra usage” and you land on a help center article now titled Manage usage credits for paid Claude plans. The URL and parts of the docs still use the old name. Same feature:

• What it is: an opt-in switch in Settings > Usage on claude.ai. With it on, a limit no longer blocks you. Requests switch to pay-as-you-go and the notice changes to “Now using credits.”
• Who gets it: Pro, Max and Ultra individuals. Team and Enterprise admins turn it on for their organization.
• What it covers: Claude chat, Claude Code and Cowork, which share one pool (see Claude Code vs Claude Cowork).
• How it’s billed: standard API rates, as a separate charge. You prepay a balance with Add funds, optionally with auto-reload.
• What it is not: the monthly API credits included with Max and Ultra. Anthropic says those don’t apply to Claude Code or to extra usage.

For the plan comparison (Pro vs Max vs API key) and how the 5-hour and weekly limits work, read Claude Code pricing first. This post covers what happens after the limit.

What Claude extra usage costs per token (November 2026)

Usage credits are “billed at standard API rates,” so the API price list is the real Claude extra usage cost. In USD per million tokens:

Model	Input	5-min cache write	Cache read	Output
Haiku 5.5 (prompts up to 100k)	$0.10	$0.125	$0.01	$0.50
Haiku 5.5 (prompts over 100k)	$0.50	$0.625	$0.05	$2.50
Sonnet 5.5	$2	$2.50	$0.10	$10
Opus 5.5	$4	$5	$0.20	$20
Fable 5.1	$10	$12.50	$0.25	$50

Two details from Anthropic’s pricing page matter for agents. Thinking is billed as output and can’t be turned off on the 5.5 and Fable models, so a one-line change can still carry thousands of output tokens. And Claude 4.7 and later use a tokenizer that produces about 30% more tokens for the same text, so old estimates run low. (Why the prompt cache matters so much is covered in Claude Code pricing.)

Usage bundles: up to 30% off, if you’ll really use them

With usage credits on, you can prepay in bundles under Settings > Usage > Buy usage: $50 of credit for $45, $250 for $200, or $1,000 for $700, up to $2,000 a month for individuals. Bundle credit is spent only after you pass your plan’s limits. It usually doesn’t expire, though in some places, such as Japan, it now expires after six months. A bundle only makes sense if you go over most weeks. Otherwise it’s a prepaid habit.

Real-world math: what an hour past the limit costs

Per-token prices only mean something once you multiply them by how an agent works. One prompt can turn into many API requests (read a file, run tests, edit, test again), and each carries the whole conversation. Here is a small estimator. Change SESSION to match what /usage shows you:

#!/usr/bin/env python3
"""Estimate what Claude usage credits (billed at standard API rates) cost per request and per hour.
Prices: USD per million tokens from platform.claude.com/docs/en/about-claude/pricing (checked 2026-11-02)."""
PRICES = {  # base input, 5m cache write, cache read, output
    "Haiku 5.5 (prompt >100k)": (0.50, 0.625, 0.05, 2.50),
    "Sonnet 5.5":               (2.00, 2.50,  0.10, 10.00),
    "Opus 5.5":                 (4.00, 5.00,  0.20, 20.00),
    "Fable 5.1":                (10.00, 12.50, 0.25, 50.00),
}
SESSION = {
    "cache_read": 150_000,   # conversation already in the prompt cache
    "cache_write": 8_000,    # new tool results / your message written to cache
    "uncached_input": 0,
    "output": 3_000,         # includes thinking tokens (billed as output)
    "requests_per_hour": 60, # agent turns fire several requests each
}
def cost(p, s):
    base, write, read, out = p
    return (s["uncached_input"]*base + s["cache_write"]*write + s["cache_read"]*read + s["output"]*out) / 1e6
def cold(p, s):  # first request after the cache expired: whole context re-written
    base, write, read, out = p
    return ((s["cache_read"] + s["cache_write"])*write + s["output"]*out) / 1e6
print(f"{'model':26} {'warm req':>9} {'cold req':>9} {'per hour':>9}")
for name, p in PRICES.items():
    w = cost(p, SESSION)
    print(f"{name:26} ${w:>8.3f} ${cold(p, SESSION):>8.3f} ${w*SESSION['requests_per_hour']:>8.2f}")

Output with those sample numbers (150k tokens of context, one request a minute). “Cold” is the first request after the cache expires, which rewrites the whole context at 1.25x the input price:

model                       warm req  cold req  per hour
Haiku 5.5 (prompt >100k)   $   0.020 $   0.106 $    1.20
Sonnet 5.5                 $   0.065 $   0.425 $    3.90
Opus 5.5                   $   0.130 $   0.850 $    7.80
Fable 5.1                  $   0.287 $   2.125 $   17.25

As a check, the example in Anthropic’s own costs doc (Sonnet 4.6: 1.2k input, 5.3k output, 940k cache read, 50k cache write) comes to $0.55 with the same formula, matching the doc. Real numbers depend on context size, effort level and subagents, so treat the table as a range, not a bill.

That’s in line with what people report on r/ClaudeCode. One Max 5x user said two extra hours past the limit cost about $56. A beginner who added a few dollars to “just wrap up and save notes” said about $15 was gone almost at once. Add a bigger context, Opus or Fable, and a few cold-cache restarts, and both fit the table.

The five things that quietly raise the bill

• Fable on Pro. On some plans Fable bills to usage credits before you hit any limit (“Requires usage credits” in /model). Interactive sessions ask for consent once; in claude -p runs, the docs say it bills without asking.
• 1M context. Sonnet 4.6 and Opus 4.6 with [1m] need usage credits on Pro, and Sonnet 4.6 [1m] needs them on every plan. If a session “suddenly costs money,” check /model for [1m].
• Fast mode. Premium-priced ($8/$40 per million on Opus 5.5). In an August r/ClaudeCode thread, users said it had started drawing on extra usage without them noticing.
• Background work. Scheduled /loop tasks, idle check-ins, agent teammates and subagents send requests while you’re not watching. Per the costs doc, agent teams use about 7x the tokens of a normal session in plan mode.
• Unattended sessions. Long autonomous jobs (see YOLO mode in Claude Code) keep going past the limit at API prices until they hit your cap.

How to cap Claude extra usage before it surprises you

Do this the same day you turn usage credits on. It takes five minutes.

1. Set a monthly spend limit. Settings > Usage > Usage credits > Adjust limit. Pick a number you’d be fine losing on a bad week, like $20. Avoid “Set to unlimited”: /usage then shows Unlimited with no spend figure.
2. Leave auto-reload off at first, so the worst case is the prepaid balance itself.
3. Check it from the terminal. /usage-credits opens the settings page, and /usage shows this month’s credit spend against your limit.
4. Pick the model deliberately. Anthropic suggests Sonnet for most coding and Opus for hard architecture work. On credits, /model sonnet (or Haiku for mechanical edits) is your biggest lever.
5. Cap headless runs. claude -p --max-budget-usd 2 "..." stops a script or CI run once estimated spend reaches the amount. It can overshoot slightly, so leave headroom.
6. Watch the windows. A status line with your 5-hour and weekly percentages warns you before you go onto credits.

This status line reads the documented rate_limits and cost fields:

#!/bin/bash
# Claude Code status line: model, 5-hour and weekly usage, estimated session cost.
input=$(cat)
MODEL=$(echo "$input" | jq -r '.model.display_name')
FIVE=$(echo "$input" | jq -r '.rate_limits.five_hour.used_percentage // empty')
WEEK=$(echo "$input" | jq -r '.rate_limits.seven_day.used_percentage // empty')
COST=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')
OUT="[$MODEL]"
[ -n "$FIVE" ] && OUT="$OUT 5h:$(printf '%.0f' "$FIVE")%"
[ -n "$WEEK" ] && OUT="$OUT 7d:$(printf '%.0f' "$WEEK")%"
# Past ~90% of a window, the next requests may bill usage credits (if you turned them on)
if [ -n "$FIVE" ] && [ "$(printf '%.0f' "$FIVE")" -ge 90 ]; then OUT="$OUT !! near limit"; fi
printf '%s est:$%.2f\n' "$OUT" "$COST"

Save it as ~/.claude/statusline-limits.sh, chmod +x it, and add to ~/.claude/settings.json:

{
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline-limits.sh"
  }
}

I fed it sample JSON on the box. Output:

[Sonnet 5.5] 5h:92% 7d:41% !! near limit est:$3.22
[Opus 5.5] est:$0.50

One caveat: rate_limits only appears for Pro, Max and Ultra logins, and only after the first response, hence no percentages on the second line. On a subscription, est: is the list-price value of the session, not a charge. On Windows you need Git Bash and jq.

When to wait instead of paying

Claude Code (v2.1.234 and later) can wait in the open session and continue on its own after the limit resets. It’s on by default for subscription logins (Continue automatically at usage limit in /config). If the reset is an hour away and nothing is on fire, waiting costs $0. A sensible rule: pay for credits only when a deadline is real. Otherwise leave a handoff note before you hit the wall:

We're close to my usage limit. Stop starting new work.
1. Write NEXT.md: what's done, what's half-done (file + function), the exact next 3 steps, and any failing test names.
2. Don't refactor or re-read files to write it. Use what's already in context.
3. Reply with one line when NEXT.md is saved.

Most credit spend goes on things you can trim: see how to reduce Claude Code token usage.

“Credit balance is too low” in Claude Code: why it happens and the fix

This error confuses a lot of subscribers. Per Anthropic’s error reference, Credit balance is too low means one of two things:

• Your Claude Console (API) organization has run out of prepaid credits, or
• Claude Code is sending your requests with a Console API key when you meant to use your subscription.

The second cause is the common one. Claude Code picks credentials in a fixed order: cloud-provider settings, then ANTHROPIC_AUTH_TOKEN, ANTHROPIC_API_KEY, apiKeyHelper, CLAUDE_CODE_OAUTH_TOKEN and Anthropic profiles. Your Pro/Max /login comes last. A key left over from an SDK project wins once approved, and you pay API prices from a Console balance that’s probably near $0. Interactive sessions ask once whether to use the key; with claude -p, the docs say a present key is always used.

A GitHub issue from this year shows how it goes wrong. A Max subscriber stripped the key with an alias in his own shell, but the agent started claude -p subprocesses, aliases don’t apply in non-interactive shells, and those subprocesses drained his prepaid API balance. Other reports involve a stale managed key from an old Console login, or WSL picking up different credentials than Windows.

The fix, in order

1. In Claude Code, run /status and read the API key / login method rows. If both exist, it marks the one not in use.
2. Find every place that sets a key. This script prints names and line numbers only, never the values:

#!/usr/bin/env bash
# Which credential will Claude Code bill? Prints NAMES and file:line only, never values.
vars="CLAUDE_CODE_USE_BEDROCK CLAUDE_CODE_USE_VERTEX CLAUDE_CODE_USE_FOUNDRY ANTHROPIC_AUTH_TOKEN ANTHROPIC_API_KEY CLAUDE_CODE_OAUTH_TOKEN ANTHROPIC_PROFILE ANTHROPIC_BASE_URL"
echo "== Environment of this shell (highest priority first) =="
found=0
for v in $vars; do
  if [ -n "${!v:-}" ]; then echo "  SET: $v"; found=1; fi
done
[ $found -eq 0 ] && echo "  none set - Claude Code should fall through to your /login subscription"
echo "== Shell profiles that set them =="
for f in ~/.bashrc ~/.bash_profile ~/.profile ~/.zshrc ~/.zprofile ~/.config/fish/config.fish; do
  [ -f "$f" ] && grep -nE "ANTHROPIC_(API_KEY|AUTH_TOKEN|BASE_URL|PROFILE)|CLAUDE_CODE_OAUTH_TOKEN" "$f" | cut -d: -f1 | sed "s|^|  $f line |"
done
echo "== Claude Code settings files with env / apiKeyHelper =="
for f in ~/.claude/settings.json .claude/settings.json .claude/settings.local.json; do
  [ -f "$f" ] && grep -nE '"(apiKeyHelper|ANTHROPIC_API_KEY|ANTHROPIC_AUTH_TOKEN|ANTHROPIC_BASE_URL)"' "$f" | cut -d: -f1 | sed "s|^|  $f line |"
done
echo "== Project env files (direnv/.env can leak a key into your shell) =="
for f in .env .env.local .envrc; do
  [ -f "$f" ] && grep -nE "^(export )?ANTHROPIC_(API_KEY|AUTH_TOKEN)=" "$f" | cut -d: -f1 | sed "s|^|  $f line |"
done
echo "Next: start claude, run /status, and confirm the login method is your Claude account."

On a throwaway home folder with fake keys in ~/.zshrc, .claude/settings.json (apiKeyHelper), .env and the environment, it flagged all four and printed none of the values:

== Environment of this shell (highest priority first) ==
  SET: ANTHROPIC_API_KEY
== Shell profiles that set them ==
  ~/.zshrc line 1
== Claude Code settings files with env / apiKeyHelper ==
  .claude/settings.json line 1
== Project env files (direnv/.env can leak a key into your shell) ==
  .env line 1

3. Remove the key: unset ANTHROPIC_API_KEY (macOS/Linux/Git Bash) or Remove-Item Env:ANTHROPIC_API_KEY (PowerShell), then delete the line that sets it. On Windows, also check System Properties > Environment Variables. A settings file’s env block overrides your shell, so unsetting it in the terminal isn’t enough.
4. To change an earlier approve/decline choice, use the Use custom API key toggle in /config (shown only while the variable is set).
5. Open a new terminal, start claude, run /login with your Claude account if needed, and check /status again.
6. Still billing the Console with nothing set? Run /logout, then /login and choose your Claude subscription, not the Console option. A leftover login from an old Console sign-in is what people in the GitHub threads usually found.

If you do want to pay by API key, as for CI, add credits at platform.claude.com/settings/billing and set a workspace spend limit, so one runaway project can’t empty the organization balance.

Cheaper than extra usage: the budget lane

Paying API prices on top of a subscription is the priciest way to buy more Claude. Compare first:

Option	What it costs	Good when
Wait for the reset	$0	Nothing is urgent
Usage credits with a cap	API rates, up to your limit	Rare crunch days
Upgrade Pro to Max 5x	$100/mo flat	You go over most weeks (the math)
Switch tools for the day	What you already pay	You have ChatGPT Plus (Codex) or another plan
Claude Code on a cheap API	Fractions of a cent per request	Bulk, mechanical work

For the last row, DeepSeek is the cheapest option, not the smartest. It offers an Anthropic-compatible endpoint (https://api.deepseek.com/anthropic) and an official Integrate with Claude Code guide, so you can point Claude Code at deepseek-flash. DeepSeek’s pricing page (checked November 2, 2026) lists $0.30 per million cache-miss input tokens, $0.006 cache-hit and $1.20 output at peak hours, half that off-peak. The estimator’s sample request comes to about $0.007 warm and $0.05 cold, against $0.065 and $0.43 on Sonnet 5.5. For hard debugging, a frontier model is still the safer pick. Since November 1, 2026, DeepSeek also bills the Search/Fetch calls ($0.75 per 1,000) that web search in Claude Code triggers.

Why it’s so cheap: cache hits (my own DeepSeek usage)

I no longer use Claude Code, but I do use the DeepSeek API (deepseek-flash) for other work, and my usage page shows why it’s cheap for agent-style workloads that resend the same context. In the 30 days to November 2, 2026 I spent ¥208.56, about $31 at the ECB reference rate for October 30, 2026 (0.1503 USD per CNY, via the Frankfurter API), on 20,515 requests and 4,714,940,244 tokens. The rest of my stack is in the real monthly cost of my AI stack.

Take October 12: 103,548,236 tokens, of which 102,381,696 were cache-hit input, 744,750 cache-miss input and 421,790 output. That’s 98.9% cache hits, and a cache hit costs 2% of the cache-miss price. At today’s list prices that day is roughly $0.67 off-peak or $1.34 peak on deepseek-flash. The same mix at Sonnet 5.5’s cache-read and output rates would be about $16, before cache-write charges. It isn’t a Claude Code workload, so read it as an illustration of the cache math, not a benchmark.

How to point Claude Code at DeepSeek without breaking your login

DeepSeek’s guide has you export ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN and model variables in your shell. But per the precedence list above, ANTHROPIC_AUTH_TOKEN outranks your Claude login, so a global export moves every Claude Code session to DeepSeek. If you also have a subscription, you can scope the guide’s settings to one command with a shell function, so claude stays on your plan and claude-deepseek uses DeepSeek:

# ~/.bashrc or ~/.zshrc
claude-deepseek() {
  CLAUDE_CONFIG_DIR="$HOME/.claude-deepseek" \
  ANTHROPIC_BASE_URL="https://api.deepseek.com/anthropic" \
  ANTHROPIC_AUTH_TOKEN="$(cat "$HOME/.config/deepseek/key")" \
  ANTHROPIC_MODEL="deepseek-flash[1m]" \
  ANTHROPIC_DEFAULT_SONNET_MODEL="deepseek-flash[1m]" \
  ANTHROPIC_DEFAULT_OPUS_MODEL="deepseek-flash[1m]" \
  ANTHROPIC_DEFAULT_HAIKU_MODEL="deepseek-flash" \
  CLAUDE_CODE_SUBAGENT_MODEL="deepseek-flash" \
  claude "$@"
}

The model lines follow DeepSeek’s guide, including mapping the Opus slot to flash; otherwise DeepSeek maps any claude-opus* name to its pricier V4 Pro model. The guide also sets CLAUDE_CODE_EFFORT_LEVEL=max and CLAUDE_CODE_AUTO_COMPACT_WINDOW=786432, which you can add the same way. I checked the function on a Linux box with a stub claude command, not a real Claude Code session: the variables reach only that command, and the shell stays clean. Keep the key in a file only you can read (chmod 600). For a per-project settings file instead, see the budget lane in Claude Code pricing; more options are in free Claude Code alternatives.

My take

Usage credits are a decent safety valve and a bad habit. Turn them on with a $20–$30 cap so a deadline never blocks you, and leave auto-reload off. If “Now using credits” shows up more than once or twice a week, change something: the session is too big (fix the context), the model is wrong for the task (Sonnet, not Opus or Fable), or the plan is too small (do the Max math). And if “Credit balance is too low” appears while you’re on a subscription, don’t add funds. Find the stray key first.

FAQ

How much does Claude extra usage cost?

The standard API rate for your model, per token, on top of your subscription. In November 2026 that’s $2/$10 per million input/output tokens for Sonnet 5.5, $4/$20 for Opus 5.5 and $10/$50 for Fable 5.1, with cheaper cache reads.

Can I turn Claude usage credits off again?

Yes, in Settings > Usage at any time. Claude Code then stops at the limit as before.

Why does Claude Code say “Credit balance is too low” when I pay for Pro?

Almost always because Claude Code is using an API key instead of your Pro login, so it charges an empty Console balance. Run /status, remove ANTHROPIC_API_KEY (and ANTHROPIC_AUTH_TOKEN) from your shell, profiles and settings files, then /login again.

Is it cheaper to upgrade or to pay for extra usage?

For a few crunch days a month, capped credits are cheaper. If your weekly credit spend adds up to near the $80/month gap between Pro and Max 5x, upgrade.