What changed with Anthropic billing on June 15, 2026?

Starting June 15, 2026, programmatic Claude usage — Claude Agent SDK, claude -p (non-interactive mode), Claude Code GitHub Actions, and third-party apps authenticating via the Agent SDK — no longer counts against your subscription's interactive usage limits. Instead, it draws from a separate monthly credit pool included with your plan: $20/month for Pro, $100/month for Max 5x, and $200/month for Max 20x. These credits are billed at standard API rates. Once exhausted, additional programmatic usage is billed directly at API prices. Interactive Claude Code sessions (the terminal REPL) stay on the subscription rate-limit bucket as before.

Does this affect regular Claude Code terminal usage?

No. Interactive Claude Code usage — the conversational terminal REPL where you type prompts and Claude responds — stays on your subscription rate-limit bucket exactly as before. The June 15 change only affects programmatic usage: claude -p (pipe mode), Claude Agent SDK invocations, Claude Code GitHub Actions, and third-party tools that authenticate via the Agent SDK.

What is 'claude -p' and why does it matter?

'claude -p' is Claude Code's non-interactive pipe mode — it accepts a prompt via stdin and returns a response without requiring a terminal session. It is commonly used in shell scripts, CI/CD pipelines, Makefiles, and automation workflows. Starting June 15, 2026, every 'claude -p' invocation draws from the programmatic credit pool (not subscription limits), which affects any automated pipeline that calls Claude programmatically.

What are the new credit pool amounts?

The monthly credit pools included with each Claude plan, effective June 15, 2026: Pro plan — $20/month in credits; Max 5x plan — $100/month in credits; Max 20x plan — $200/month in credits. These credits are consumed at standard API list prices (not the discounted subscription rate). When credits are exhausted, usage bills directly to your payment method at API rates. Interactive Claude Code usage does NOT draw from these credits.

Which tools are affected by the June 15 billing change?

The following tools are moved to the programmatic credit pool: (1) Claude Agent SDK — any code using the Python or TypeScript SDK to call Claude programmatically; (2) claude -p — the non-interactive pipe mode of Claude Code; (3) Claude Code GitHub Actions — any CI/CD workflow using the official Claude Code Action; (4) Third-party applications — any app that authenticates via the Agent SDK using your subscription. The interactive Claude Code terminal is NOT affected.

How much do Agent SDK calls actually cost?

Costs depend on the model and token counts. At standard API prices for Claude Opus 4.6 (the default for Claude Code): input tokens cost $15 per million, output tokens cost $75 per million, and prompt cache writes cost $3.75 per million. A typical Agent SDK task using 50K input + 10K output tokens costs approximately $1.50. At $20/month in credits (Pro plan), that is roughly 13 Agent SDK tasks before credits are exhausted. Workflows with high output token counts (code generation) hit limits faster than mostly-read tasks.

What happens after the credit pool is exhausted?

After the monthly credit pool is exhausted, programmatic usage (Agent SDK, claude -p, GitHub Actions) continues but bills directly to your payment method at standard API list prices. There is no hard cutoff that stops your agents mid-task. You will receive usage billing on top of your subscription fee. To avoid surprise charges, set up billing alerts in your Anthropic account settings and monitor programmatic usage separately from interactive usage.

How does this affect Claude Code GitHub Actions?

Every Claude Code GitHub Action run now draws from the programmatic credit pool. A CI/CD pipeline that calls Claude for code review, test generation, or automated PRs will consume credits proportional to the tokens processed. For a team running 50 CI/CD jobs per day with a 10K token average per job, that is approximately 1.5M tokens/month — at Sonnet 4.6 rates ($3/M input, $15/M output), roughly $12-18/month in programmatic credits. This fits within the Pro tier's $20 credit but would exceed it for heavier workloads requiring upgrade to Max 5x.

Can I use amux to track programmatic spending?

Yes. amux reads Claude Code JSONL transcript files and aggregates token usage per session, letting you see which sessions (interactive vs programmatic) are consuming the most tokens. For sessions launched via claude -p or the Agent SDK, amux's token tracking shows daily and per-task token counts that map directly to credit pool consumption. This visibility helps you identify expensive automation workflows before they exhaust the monthly pool. See the token-spend tracking guide for setup instructions.

Anthropic Agentic Billing Change: What Every Developer Must Know (June 15, 2026)

Starting June 15, 2026, Claude Agent SDK, claude -p, and Claude Code GitHub Actions move off your plan’s subscription limits onto a separate tiered credit pool. Here is the complete breakdown of what changed, who is affected, and how to manage costs before and after the change.

⚠️

June 15, 2026 (3 days away). Programmatic Claude usage — Agent SDK, claude -p, GitHub Actions, third-party SDK apps — stops counting against subscription interactive limits. A new credit pool activates. Interactive Claude Code terminal sessions are unchanged. Check your Anthropic console to set billing alerts before June 15.

TL;DR: Programmatic Claude usage gets its own credit pool matching your plan price: Pro = $20/mo, Max 5x = $100/mo, Max 20x = $200/mo. Credits bill at standard API rates. Once exhausted, usage bills beyond the subscription. Interactive claude terminal sessions are NOT affected. CI/CD pipelines, shell scripts using claude -p, and Agent SDK code all draw from the new pool starting June 15.

What Changed and Why

Before June 15, 2026, all Claude usage — whether you typed a prompt interactively in the Claude Code terminal or called the Agent SDK from a Python script — drew from the same rate-limit bucket included with your plan. A Claude Pro subscriber got a single pool of usage that covered everything: interactive conversations, claude -p calls in shell scripts, SDK invocations, and GitHub Actions.

Starting June 15, 2026, Anthropic splits this into two buckets:

Interactive bucket — Claude Code terminal (REPL), claude.ai web, Claude desktop app. Stays on subscription rate limits, unchanged.
Programmatic credit pool — Claude Agent SDK, claude -p, Claude Code GitHub Actions, third-party apps via Agent SDK. Gets its own monthly credit allowance, billed at API rates. Once exhausted, usage bills as pay-as-you-go API charges on top of your subscription.

Anthropic's reasoning: agentic and programmatic workloads have fundamentally different cost profiles from interactive chat. A single Agent SDK workflow can consume more tokens in one run than weeks of interactive chat. Separating the pools lets Anthropic offer predictable subscription pricing for interactive use while giving programmatic users a transparent, scalable cost model.

Confirmed by primary sources. This change is documented in Anthropic's official support article and independently confirmed by Zed's engineering blog, The New Stack, TechTimes, and developer community discussions on Hacker News.

Which Tools Are Affected

▶
Claude Agent SDK (Python + TypeScript)
Any code using anthropic.Anthropic() or @anthropic-ai/sdk to call Claude programmatically. This includes agent frameworks, scripts, batch processing, and custom tooling built on the SDK.
▶
claude -p — Claude Code non-interactive mode
The pipe/print mode of Claude Code, used in shell scripts, Makefiles, CI/CD hooks, and automation. Example: echo "review this code" | claude -p or claude -p --output-format json "summarize changes".
▶
Claude Code GitHub Actions
The official Anthropic GitHub Action that runs Claude Code in CI/CD pipelines — for automated code review, PR summaries, test generation, and documentation updates.
▶
Third-party applications via Agent SDK
Any third-party tool that authenticates using your Claude subscription through the Agent SDK (rather than an API key). If a tool asks you to log in with your Claude subscription, it may be affected.
▶
Interactive Claude Code terminal — NOT affected
The conversational REPL you open in a terminal, type prompts into, and read responses from. This stays on subscription rate limits exactly as before. Your daily interactive workflow is unchanged.

New Credit Pool Tiers

$20

Pro plan
monthly credit pool

$100

Max 5x plan
monthly credit pool

$200

Max 20x plan
monthly credit pool

Each plan includes a monthly credit pool for programmatic usage, with the credit amount matching the plan's subscription price:

Plan	Subscription Cost	Programmatic Credit Pool	Interactive Usage	After Credits Exhausted
Claude Pro	$20/month	$20/month at API rates	Unchanged rate limits	Pay-as-you-go API rates
Claude Max 5x	$100/month	$100/month at API rates	5x subscription limits	Pay-as-you-go API rates
Claude Max 20x	$200/month	$200/month at API rates	20x subscription limits	Pay-as-you-go API rates

Credits are not "free" in the traditional sense. The credit pool is included with your subscription but consumed at standard API list prices — the same rates you'd pay if you had a direct API key. The credits don't go further just because they're bundled. A $20 credit pool consumed by Claude Opus 4.6 at $15/M input tokens yields approximately 1.33M input tokens, or about 13–20 typical Agent SDK tasks.

Cost Math: Real Examples

The following examples use Anthropic's standard API pricing for the models commonly used with Claude Code. All costs are in USD.

Example 1: Daily shell scripts using `claude -p`

5 script calls/day × 30 days = 150 calls/month Each call: ~5K input + ~1K output tokens Input cost: 150 × 5,000 × ($15 / 1,000,000) = $11.25/mo Output cost: 150 × 1,000 × ($75 / 1,000,000) = $11.25/mo Total: ~$22.50/month

Result: Exceeds the Pro plan's $20 credit pool. You'd pay ~$2.50 as overage at API rates. Consider upgrading to Max 5x or switching lighter automation to Sonnet 4.6 (3–5x cheaper output).

Example 2: Agent SDK workflow for nightly code review

1 nightly run × 30 days = 30 runs/month Each run: ~50K input + ~15K output tokens (large codebase review) Input cost: 30 × 50,000 × ($15 / 1,000,000) = $22.50/mo Output cost: 30 × 15,000 × ($75 / 1,000,000) = $33.75/mo Total: ~$56.25/month

Result: Exceeds both Pro ($20) and Max 5x ($100 if combined with other usage) credit pools. Consider batching reviews (weekly instead of nightly), using Sonnet 4.6 for initial triage, or routing to the direct API with a separate key.

Example 3: Lightweight automation — commit message generation

10 commits/day × 22 working days = 220 calls/month Each call: ~2K input (diff) + ~0.2K output (commit message) Input cost: 220 × 2,000 × ($3 / 1,000,000) = $1.32/mo (Sonnet 4.6) Output cost: 220 × 200 × ($15 / 1,000,000) = $0.66/mo Total: ~$2/month

Result: Well within the Pro plan's $20 credit pool. Lightweight claude -p automation using Sonnet 4.6 for simple tasks is very cost-effective even after the billing change.

Example 4: amux parallel agent fleet (10 sessions, overnight)

10 agents × 4 hours/night × 22 nights/month = 880 agent-hours Average: 25K input + 8K output tokens per agent per hour Input cost: 880 × 25,000 × ($15 / 1,000,000) = $330/mo Output cost: 880 × 8,000 × ($75 / 1,000,000) = $528/mo Total: ~$858/month

Result: A 10-agent overnight fleet is a heavy workload that far exceeds any subscription credit pool. For this scale, use a direct API key via ANTHROPIC_API_KEY environment variable rather than subscription auth. See the full cost guide for fleet cost optimization strategies.

Impact on Claude Code GitHub Actions

The Claude Code GitHub Action lets teams automate code review, PR summaries, test generation, and documentation updates in their CI/CD pipelines. Starting June 15, every Action run draws from the programmatic credit pool.

Common Action use cases and estimated monthly costs (assuming 50 PRs/month for a small team):

Use Case	Tokens per Run	50 PRs/month (Sonnet 4.6)	50 PRs/month (Opus 4.6)
PR summary	~3K in / ~0.5K out	~$1/mo	~$3/mo
Code review comments	~15K in / ~3K out	~$4.50/mo	~$15/mo
Test file generation	~20K in / ~8K out	~$7.50/mo	~$25/mo
Full automated review pipeline	~50K in / ~15K out	~$18/mo	~$56/mo

Claude Sonnet 4.6 pricing: $3/M input, $15/M output. Claude Opus 4.6 pricing: $15/M input, $75/M output. For CI/CD automation, Sonnet 4.6 is almost always the right choice — it costs 5× less than Opus for similar code review quality on most tasks.

Tip for GitHub Actions. Set the model explicitly in your Action config: model: claude-sonnet-4-6 to avoid accidentally using Opus for routine automation. Reserve Opus for tasks requiring deep reasoning (architectural analysis, complex bug diagnosis).

Pre-June 15 Checklist

Audit programmatic usage. Run grep -r "claude -p\|anthropic\|claude-code" .github/ scripts/ Makefile to find every place your automation calls Claude.
Estimate monthly token volume. Use the cost examples above to project whether your usage fits within your plan's credit pool. If it doesn't, upgrade your plan or switch to direct API key auth.
Set billing alerts. In the Anthropic Console, set spending alerts at 50%, 80%, and 100% of your credit pool so you're notified before hitting overage charges.
Choose the right model for each task. Use Claude Sonnet 4.6 for routine automation (code review, summaries, formatting) and Opus only for complex reasoning tasks. This alone can reduce costs by 5×.
For heavy workloads, use a direct API key. Set ANTHROPIC_API_KEY in your environment and Claude Code / SDK tools will use it instead of subscription auth, bypassing the credit pool entirely and billing directly at API rates.
Review third-party integrations. Check if any tools your team uses authenticate via your Claude subscription. They'll now draw from the credit pool. Check the tool's docs for a dedicated API key path.
Update amux session configs. If you launch amux agents via claude -p or the Agent SDK (rather than the interactive terminal), those sessions now draw from the credit pool. See token spend tracking to monitor them.

Monitoring Programmatic Spend with amux

amux reads Claude Code JSONL transcript files and shows per-session token usage in the web dashboard. After June 15, this lets you see which agent sessions are consuming programmatic credits versus interactive quota.

Sessions launched interactively (where you type prompts) use the subscription interactive bucket.
Sessions launched via claude -p, shell hooks, or Agent SDK calls draw from the credit pool.
amux's token tracking shows daily token counts per session, letting you identify high-cost automation and set session-level spending thresholds.

# View per-session token usage in amux
curl -sk http://localhost:8822/api/sessions | python3 -c "
import json, sys
sessions = json.load(sys.stdin)
for s in sessions:
    tokens = s.get('token_count', 0)
    print(f\"{s['name']:30} {tokens:>10,} tokens\")
"

# Or open the amux dashboard at http://localhost:8822
# → Sessions tab → each session shows token usage

For a more detailed breakdown, use the token spend tracking guide, which covers setting up per-session JSONL monitoring, daily cost reports, and Slack/email alerts when a session exceeds a budget threshold.

Frequently Asked Questions

Does this affect my regular Claude Code terminal sessions?+

No. Interactive Claude Code usage — the terminal REPL where you type prompts and read responses — stays on subscription rate limits exactly as before. The June 15 change only affects programmatic usage: claude -p, Agent SDK calls, GitHub Actions, and third-party apps via the SDK.

What happens when I exhaust the monthly credit pool?+

Usage continues uninterrupted but bills as pay-as-you-go API charges on top of your subscription. There is no hard cutoff. Your agents will not fail mid-task. You will see overage charges on your next billing statement. Set spending alerts in the Anthropic Console to be notified before hitting the limit.

How do I avoid overage charges?+

Three strategies: (1) Use Claude Sonnet 4.6 instead of Opus for routine automation — 5× cheaper with comparable results for most tasks. (2) Set an ANTHROPIC_API_KEY environment variable for heavy workloads — SDK and claude -p tools use the key directly, bypassing the subscription credit pool. (3) Batch operations to reduce token overhead (fewer, larger calls instead of many small calls).

Is claude -p (pipe mode) the same as Claude Code interactive mode?+

claude -p (or claude --print) is Claude Code's non-interactive mode — it accepts a prompt as an argument or via stdin and exits after responding. It is used in scripts, Makefiles, and CI/CD. It is different from the interactive terminal REPL (where you open a conversation and type back and forth). As of June 15, 2026, claude -p draws from the programmatic credit pool, not the interactive bucket.

Should I switch to a direct API key instead of subscription auth?+

For heavy programmatic workloads that would exceed your credit pool, a direct API key is cleaner — you pay exactly what you use, with no subscription bundle overhead. Set ANTHROPIC_API_KEY in your environment and Claude Code, Agent SDK tools, and GitHub Actions will use it automatically. For lighter automation that fits within the credit pool, subscription auth is simpler — no key rotation required.

Do the credit pools roll over month to month?+

No. Based on Anthropic's standard credit policies, unused programmatic credits do not roll over to the next month. Credits reset on your billing cycle date. Plan usage accordingly — don't save heavy automation work for end-of-month if you have unused credits; start CI/CD pipelines early in the cycle.

Track Token Spend Across All Your Agent Sessions

amux shows per-session token usage, daily cost estimates, and multi-agent spend visibility — helping you stay within budget before and after the June 15 billing change.

View on GitHub Token Spend Tracking Guide