Claude Code Pricing 2026: Autonomous Credits and What Changed
TL;DR: Claude Code subscriptions now distinguish between two types of work. Your interactive, human-in-the-loop sessions in the IDE or terminal continue to use your plan's standard limits as before. Autonomous tasks, such as those using the Agent SDK or GitHub Actions, now draw from a new, separate monthly credit specific to your plan. This credit is consumed first, and you can opt in to allow overages at standard API rates once it's depleted.
Anthropic has introduced a significant update to Claude Code pricing, creating a clear distinction between interactive and autonomous usage. Your workflow is now categorized into two buckets.
Human-in-the-loop work covers your active, hands-on sessions in the Claude Code terminal, IDE, web chat, or Cowork. These continue to draw from your subscription's existing usage limits exactly as they did before.
The major change applies to Autonomous work, which includes tasks run via the Agent SDK, non-interactive CLI commands (claude -p), and the official GitHub Actions integration. This type of usage is now billed against a new, separate monthly credit.
Each plan receives a monthly autonomous credit that refreshes with your billing cycle:
- Pro ($20/month): $20 autonomous credit
- Max 5x ($100/month): $100 autonomous credit
- Max 20x ($200/month): $200 autonomous credit
If your autonomous usage exceeds this credit, all autonomous work stops unless you have explicitly enabled "extra usage," which allows overages at standard API rates.
This presents three clear paths forward depending on your workflow. You can keep your autonomous tasks within the new monthly credit limit. You can move autonomous workloads to the Claude API or a platform like Codex. Or you can take a hybrid approach, using Claude Code for interactive coding while offloading long-running jobs elsewhere.
I write about AI coding tools weekly on my Substack. If you want practical setup guides for these workflows, subscribe there.
What changed in the Claude Code pricing update
Effective June 15, 2026, Anthropic updated its pricing by introducing a clear distinction between two types of usage: human-in-the-loop and autonomous.
Human-in-the-loop usage covers interactive work and continues to be billed against the existing plan's usage limits. This category includes:
| Activity | Category |
|---|---|
| Interactive Claude Code in terminal | Human-in-the-loop |
| IDE integration (VS Code extension) | Human-in-the-loop |
| Claude web chat (claude.ai) | Human-in-the-loop |
| Claude Desktop app | Human-in-the-loop |
| Claude Cowork | Human-in-the-loop |
Autonomous usage is for automated tasks and now draws from a separate monthly autonomous credit. This credit must be claimed once by the user to activate.
| Activity | Category |
|---|---|
| Agent SDK (Python and TypeScript) | Autonomous |
claude -p (non-interactive mode) | Autonomous |
| Claude Code GitHub Actions | Autonomous |
| Third-party apps authenticating via subscription | Autonomous |
The autonomous credit is allocated per user, refreshes monthly with the billing cycle, and does not roll over. Once depleted, autonomous usage stops unless the user has explicitly enabled extra usage.
What counts as autonomous vs human-in-the-loop?
The distinction comes down to whether you are actively controlling the session or whether Claude is running unattended.
| Activity | Category | Credit Impact | Notes |
|---|---|---|---|
| Terminal (Claude Code) | Human-in-the-loop | Uses plan subscription limits | Interactive sessions only |
| IDE integration | Human-in-the-loop | Uses plan subscription limits | VS Code extension, interactive use |
| Web chat | Human-in-the-loop | Uses plan subscription limits | claude.ai conversations |
| Desktop app | Human-in-the-loop | Uses plan subscription limits | Claude Desktop application |
| Cowork | Human-in-the-loop | Uses plan subscription limits | Collaborative sessions |
| Agent SDK | Autonomous | Draws from monthly autonomous credit first; optional extra usage at API rates after credit | Applies to Python and TypeScript projects and third-party apps authenticating via your subscription |
claude -p | Autonomous | Draws from monthly autonomous credit first; optional extra usage at API rates after credit | Non-interactive CLI mode only |
| GitHub Actions | Autonomous | Draws from monthly autonomous credit first; optional extra usage at API rates after credit | Official Claude Code GitHub Actions integration |
If you are typing commands and reviewing output in real time, that is human-in-the-loop. If you fire off a task and walk away, that is autonomous.
How much do autonomous credits cost?
Each subscription tier includes a matching monthly autonomous credit.
| Plan | Monthly Price | Monthly Autonomous Credit |
|---|---|---|
| Pro | $20 | $20 |
| Max 5x | $100 | $100 |
| Max 20x | $200 | $200 |
How the credit mechanics work
The rules governing these credits are straightforward.
Per-user, not pooled. Credits belong to individual accounts. They cannot be shared or pooled across teammates.
Refreshes monthly. Your credit resets at the start of each billing cycle. Unused credits do not roll over to the next cycle.
One-time opt-in. You claim your credit through your Claude account once. After that, it refreshes automatically each cycle.
Drains first. Agent SDK usage draws from your monthly credit before any other source.
Overages are opt-in. When your monthly credit runs out, additional autonomous usage flows to extra usage at standard API rates, but only if you have enabled extra usage. If you have not, autonomous work simply stops.
What are your options now?
There are three practical paths forward depending on how you use Claude Code.
Option 1: Stay on Claude and budget autonomous usage within credits
Keep your current Claude subscription and manage autonomous workflows to stay within the new monthly autonomous credit.
Your interactive work remains unchanged. Autonomous tasks draw from a separate, predictable credit pool. You manage a single subscription and can track per-user autonomous spending without separate API keys.
The trade-off is that the autonomous budget is fixed per user and cannot be pooled across a team. Heavy autonomous workflows may stall once the credit is depleted, unless you enable extra usage at API rates.
This option works best if your autonomous usage is light or predictable.
Option 2: Move autonomous workflows to Codex or API
Migrate your autonomous workloads entirely to the Claude API (pay-as-you-go) or to a competing platform like OpenAI's Codex.
This gives you uncapped autonomous compute. No monthly credit limit to worry about. You pay for exactly what you use.
The trade-off is managing a second billing relationship. You lose the simplicity of a single subscription. You also need to evaluate whether Codex's model quality and tooling meet your needs for specific tasks.
This option works best if you run heavy, unpredictable autonomous workloads that regularly exceed the autonomous credit.
Option 3: Hybrid approach
Use your Claude Code subscription for interactive coding. Offload long-running autonomous jobs to the API or Codex.
This captures the best of both worlds. Your interactive experience stays the same. Your autonomous credit covers light automation. Heavier jobs go to a system designed for scale.
The trade-off is complexity. You are managing two systems, two billing models, and two sets of tooling.
Should you change your plan?
The answer depends on your usage pattern.
If most of your work is in the terminal or IDE, nothing changes. Your interactive sessions use the same subscription limits as before. The autonomous credit is a bonus you may never touch.
If you use claude -p or the Agent SDK occasionally, the included autonomous credit will likely cover you. A Pro plan gives you $20 in autonomous credit per month. For occasional scripted tasks, that goes a reasonable distance.
If you run agents overnight or schedule unattended jobs, do the maths. Calculate your typical monthly token consumption for autonomous tasks. Compare it against the autonomous credit included in your plan. If you consistently exhaust the credit, you have two choices: enable extra usage and pay API rates for overages, or migrate those specific workloads to the Claude API directly or to Codex cloud tasks.
If you are on a team, remember that credits are per-user and not pooled. A team of five on Max 5x gets five separate $100 credits, not one $500 pool. Plan accordingly.
The pricing update does not change the value proposition for most interactive Claude Code users. It primarily affects power users who built autonomous pipelines on top of a subscription that was never priced for that level of compute.
If you want help setting up an autonomous coding stack that fits your budget, join the course waitlist. I will email practical modules, examples, and calculators when it opens.