Anthropic moves Claude Agent SDK and `claude -p` to a credit pool

Starting June 15, 2026, anything that runs through the Claude Agent SDK or the claude -p non-interactive command stops drawing from your subscription pool and starts draining a separate monthly credit: $20 on Pro, $100 on Max 5x, $200 on Max 20x. Interactive Claude Code in your terminal and IDE keeps using your normal subscription limits — only programmatic and headless usage moves to the new pool, and when the pool empties, requests pause unless you opt into extra usage at standard API rates. If your day-to-day workflow leans on claude -p, CI agents, or third-party harnesses authed through the SDK, you have about a month to decide whether the new credit covers you, whether to flip to an API key, or whether to run both.

What Exactly Changes on June 15, 2026?

Anthropic split interactive Claude usage from programmatic Claude usage. Both used to share the same per-plan rate limits; from June 15 onward, programmatic usage runs out of a fixed monthly pool that refills on your billing cycle. The change is targeted at "compute arbitrage" — Max subscribers piping OAuth tokens into headless harnesses and consuming what would have cost 5–10x more on the API.

The interactive side of Claude Code is, on purpose, untouched. If you only use Claude through the terminal and your IDE, you will not see any difference on June 15. Everything below applies to people who run Claude programmatically — CI pipelines, batch jobs, scheduled tasks, custom agents, and tools that authenticate through the SDK.

Which Plans Get Credits, and How Much?

Five plans qualify. The credit refreshes each billing cycle, does not carry over, and is tied to an individual account — Team and Enterprise plans give each seat its own credit pool rather than a shared bucket.

The credit lands in your account on a one-time opt-in. Eligible users get an email from Anthropic before June 15 with a claim link. If you do not opt in, your Agent SDK and claude -p requests will start returning rate-limit errors after the cutover — the old subscription pool stops covering them either way.

What Counts Against the New Credit?

Anything that hits Anthropic's API on behalf of your subscription account, without a human typing at the REPL, draws from the new pool. That includes a few cases that surprise people on first read:

• claude -p "…" and any shell pipeline that pipes input into Claude Code. This is the headline change — most CI and cron scripts use exactly this entry point.
• Calls from the Claude Agent SDK — @anthropic-ai/claude-agent-sdk (TypeScript) and claude-agent-sdk (Python) — whether you launch them from a script, a worker, or a custom CLI.
• The Claude Code GitHub Actions integration. PR review bots, auto-fix workflows, and any other action that authenticates with your subscription credentials runs on the new credit.
• Approved third-party harnesses authed via the SDK. Anthropic requires partner approval before a third-party tool can offer subscription-based login at all, so most OpenClaw-style passthroughs already stopped working in April 2026 — the survivors live on the new credit.
• Subagents and scheduled tasks launched from headless sessions. They inherit their parent's billing context, so a long-running Agent SDK loop with five subagents pulls tokens from one credit pool.

What Does Not Change?

Interactive workflows stay exactly where they were. Anthropic deliberately drew the line between "a human is at the keyboard" and "a script is running unattended."

• Claude Code in the terminal — REPL sessions, slash commands, interactive plan mode, and IDE plugins (VS Code, JetBrains) keep drawing from your subscription rate limits.
• claude.ai web and desktop apps — chat, projects, Artifacts, file uploads, and Computer Use stay on subscription limits.
• Claude Cowork — same pool as the web app.
• The Developer Platform API — keys created in console.anthropic.com / platform.claude.com billed pay-as-you-go are not touched by the change.

One subtle consequence: an interactive Claude Code session that spawns a headless subagent through the SDK starts mixing pools. The interactive turns bill against your subscription; the SDK turns bill against the credit. Track both if you care.

How Far Does $20 / $100 / $200 Actually Go?

The credit is denominated in dollars at standard API rates. To turn that into something useful, anchor on a Sonnet 4.6 turn — the workhorse model for most headless Claude Code work. A representative coding turn looks like 8k input tokens (CLAUDE.md, file context, prior turn) and 1.5k output tokens — call it $0.0465 per turn at base rates ($3/MTok in, $15/MTok out). Add prompt caching (a baseline harness optimisation) and 80% of those input tokens are cache reads at 10% of base — drops the per-turn cost to roughly $0.029.

Opus 4.7 changes the math sharply — it costs 5x more input and 1.67x more output than Sonnet 4.6 ($5/$25 vs $3/$15 per MTok), and its updated tokenizer can use up to 35% more tokens for the same text. With 80% cache hits, a Max 20x credit on Opus 4.7 covers roughly 4,000 typical coding turns; on Sonnet 4.6 the same $200 covers around 6,900. Drop cache hits and the gap widens — Opus naive is closer to 2,500 turns.

Three multipliers compound in the other direction. Prompt caching cuts repeated context to 10% of base. The Batch API halves both input and output costs for asynchronous workloads. Routing trivial subtasks to Haiku 4.5 ($1/$5 per MTok) gets you another 3x on the cheap end. Stack all three and a Max 20x credit can absorb a workload that would cost $1,500–$2,000 at naive Opus 4.7 rates.

Should You Switch to an API Key?

The credit is right-sized for individual experimentation and ad-hoc automation. Once you cross into team-shared or production workloads, an API key is the better fit — credits cannot pool, and predictable pay-as-you-go billing is easier to budget around than a fixed pool that rolls over to nothing.

Hybrid is usually right. Keep your subscription for interactive Claude Code, claim the credit for personal automation, and put a Developer Platform key in ANTHROPIC_API_KEY for anything that runs in CI or production. The Agent SDK reads that env var transparently — the same script can target both backends by switching one variable.

# Local: use your subscription credit (after one-time opt-in)
claude-agent-sdk run ./agent.py            # auth via Claude Code session

# CI: use a Developer Platform API key (pay-as-you-go)
ANTHROPIC_API_KEY=$ANTHROPIC_API_KEY \
  claude-agent-sdk run ./agent.py          # bills to your org's API account

Store the API key in your CI provider's secret store, never in the repo — see the GitHub Actions secrets and env vars guide for the OIDC pattern.

What Should You Do Before June 15?

Five concrete steps, in order. None of them are reversible enough to be scary, but the audit step usually surfaces something — most teams under-count how many places claude -p has crept into.

1. Watch for the opt-in email from Anthropic. One-click claim; you have to do it once per eligible account. Skip this and you lose the credit on June 15 even if you pay for the plan.
2. Inventory your headless usage. Grep for claude -p, @anthropic-ai/claude-agent-sdk, claude-agent-sdk, and claude-code-action across your repos. Note which run on your subscription account vs. an API key.
3. Estimate monthly token spend. The Claude Code /cost command shows per-session input/output tokens; multiply by your typical session count. Compare to the $20/$100/$200 ceiling.
4. Decide on extra-usage billing. The toggle controls what happens after credits empty: pause requests (default, predictable) or auto-bill at standard API rates (uninterrupted, harder to cap). Pick deliberately.
5. Move team-shared workloads to API keys. Create one Developer Platform key per service, store it in your CI's secret manager, and update CI workflows to set ANTHROPIC_API_KEY before invoking the SDK or claude -p.

If any of your automation involves talking to external systems through MCP servers, the cutover is also a good time to audit which servers your agents have access to — the SDK gives subagents their own permission context, and credit discipline pairs naturally with tool discipline.

When Should You Not Use the Subscription Credit?

• Shared team automation — credits are per-account and explicitly cannot be pooled. Five engineers on Max 20x is $1,000 of plan spend for $1,000 of unpooled credit; the same $1,000 on an API key buys roughly the same Sonnet tokens but with audit logs, team billing, and Batch API discounts that credits do not get.
• Anything where a paused request would page someone — credits run out, requests stop. An API key fails closed on rate limits, not on a $20 ceiling.
• Building a product that authenticates users through Claude — Anthropic does not allow third-party developers to offer claude.ai login or rate limits to their own customers without prior approval. Your users need their own keys.
• Sustained nightly batch jobs — the Batch API gives 50% off for 24-hour async workloads. That discount applies only to Developer Platform usage, not to the credit.
• Workflows that would be cheaper locally — for repetitive autocomplete, code review on small files, and other high-volume low-stakes work, a 24 GB GPU running Qwen2.5-Coder 32B locally is free at the margin once the hardware is paid for.

What About the Harness?

The Agent SDK is the harness Anthropic exposes for headless work — same tool loop, hooks, subagents, skills, and MCP support as interactive Claude Code, programmable in Python and TypeScript. If you have been following Anthropic's own writing on harness engineering, the credit change does not invalidate any of it. What it does is move the cost ledger from "hidden inside my $200 Max plan" to "a number you have to plan against."

# Python
pip install claude-agent-sdk

# TypeScript / Node — bundles the Claude Code binary as an optional dep
npm install @anthropic-ai/claude-agent-sdk

Teams already running a Level 3+ spec-driven agentic factory almost certainly outgrew the subscription credit on day one — the workloads in our cost table sit between $30 and $800/month before optimisation. That is what API keys are for. The credit's real audience is the long tail of individual developers who want to leave a script running overnight without thinking about per-token cost — and that audience now has a clean billing line for it.

Frequently Asked Questions

References

• Anthropic — Use the Claude Agent SDK with your Claude plan — the canonical support article: eligible plans, credit amounts, opt-in mechanics, and what the credit covers
• Claude Agent SDK overview — official SDK reference: install commands, capabilities (tools, hooks, subagents, MCP, sessions), authentication, and the note flagging the June 15, 2026 billing change
• Claude API pricing (platform.claude.com) — current per-million-token rates for Opus 4.7, Sonnet 4.6, and Haiku 4.5, plus prompt-caching and Batch API multipliers
• Anthropic — Building agents with the Claude Agent SDK — the engineering blog post that introduced the rename from Claude Code SDK and walks through the agent loop
• Anthropic — Effective harnesses for long-running agents — the harness-engineering reference that informs how to size your SDK workloads
• anthropics/claude-agent-sdk-python — the Python SDK repository and changelog
• anthropics/claude-agent-sdk-typescript — the TypeScript SDK repository and changelog
• HN discussion — "Claude subscription changes coverage of `claude -p`" — community sentiment and worked examples of how Max users priced the change