# Claude Code Heavy Users: API vs Subscription, Keep or Downgrade?

> As of October 10, 2026, heavy interactive Claude Code use is usually cheaper on Pro or Max than on API billing. Max's monthly API credits cover only automation.

- URL: https://blog.laozhang.ai/en/posts/claude-api-vs-subscription-cost
- Published: 2026-07-08
- Updated: 2026-10-10
- Author: LaoZhang AI Team (https://blog.laozhang.ai/en/about)
- Topic: Claude Code
- Tags: Claude Code, Claude Pricing, Claude API, API Billing, Anthropic

---
As of October 10, 2026, most heavy Claude Code users should keep a Pro or Max subscription for interactive work and put only unattended work on API billing: apps, CI jobs, scheduled agents, and batch runs. The reason is simple arithmetic. At API list prices, one large Opus 5.5 turn with 200K tokens of context in and 20K tokens out costs about $1.20, so the $100 price of Max 5x buys roughly 83 such turns a month at API rates. Someone who drives Claude Code for hours every workday passes that early in the month. If you only hit plan limits during occasional burst weeks, Pro plus capped usage credits is the cheaper middle ground.

Three changes since early 2026 move the math, and older "subscription is 36x cheaper" comparisons don't include them:

- **Max now includes API credits.** Since October 7, 2026, Max 5x includes $100 and Max 20x $200 of Claude API credit each month. That credit pays for API calls, the Agent SDK, and the Console, not for interactive Claude Code sessions or usage credits.
- **Fable depends on the plan.** On Max, up to 50% of the weekly limit can go to Fable 5 and 5.1 at no extra cost. On Pro, Fable isn't included in plan limits, so every Fable request is billed as usage credits at API rates.
- **API prices are lower for the newest models.** Opus 5.5 is $4 input and $20 output per million tokens, Sonnet 5.5 is $2 and $10, and Fable 5.1 is $10 and $50.

Before comparing prices, answer four checks:

| Check | What to look at | Why it matters |
| --- | --- | --- |
| Active Claude Code credential | Run `/status` | `/status` marks the credential that isn't in use, so you can see whether the session bills your plan or an API key. |
| API-key override | `ANTHROPIC_API_KEY` and `ANTHROPIC_AUTH_TOKEN` in the shell that launched Claude Code | In interactive mode, Claude Code asks once whether to use a key it finds and remembers the answer. With `claude -p`, the key is always used. |
| Subscription pressure | Claude Settings > Usage, or `/usage` in Claude Code | Shows the five-hour session bar, the weekly bar, and the usage credits controls. |
| API spend | Claude Console Usage/Cost and Billing | Shows token spend by project, the prepaid credit balance, and any Max or Team monthly API credit. |

The stop rule hasn't changed: don't cancel Max, buy credits, or move heavy Claude Code work to the API until you know which dashboard owns the spend. A subscription usage bar, Claude Code `/usage`, and Console usage report different things. Mixing them is how "API is cheaper" and "subscription is cheaper" claims end up wrong for a real workload.

## The Route Decision In One Table

The useful comparison isn't a plan price against one API price row. It's who does the work against which bill should carry it. A heavy human session and an unattended automation run can use the same model, but they shouldn't be budgeted the same way.

| Workload pattern | Start with | Why | Don't do this |
| --- | --- | --- | --- |
| One developer running Claude Code interactively for long sessions | Pro or Max subscription after the credential check | The work belongs to a named person, and API-rate cost for long-context turns adds up fast. | Don't switch to the API because one forum thread reports a cheaper session. |
| The same developer occasionally exceeds included limits | Subscription plus capped usage credits or a usage bundle | Paid overflow covers burst weeks without moving all interactive work to token billing. | Don't treat usage credits as free or uncapped. |
| A developer who relies on Fable 5.1 | Max | Max counts Fable against plan limits (up to 50% of the weekly limit). Pro bills it as usage credits from the first request. | Don't stay on Pro and pay about $3 per large Fable turn in credits. |
| A Max user who also runs scripts, the Agent SDK, or `claude -p` with a key | Max plus a linked Console organization | The monthly API credit ($100 or $200) is spent before any purchased API credit. | Don't buy API credit before claiming the Max credit. |
| Backend feature, customer-facing app, CI, scheduled agent, batch job | Claude API billing | The project needs API keys, spend limits, rate limits, and auditable usage. | Don't squeeze production automation through a personal subscription. |
| Surprise Claude Code API charges | Fix the active credential first | An API key can make Claude Code bill the Console even while you keep a subscription. | Don't upgrade or downgrade until `/status` and the environment agree. |
| Team with both human coding and automation | Seats for people, API budgets for automation | Governance is cleaner when people and projects have separate budgets. | Don't buy Premium seats to fund automation that belongs in API projects. |

For heavy interactive Claude Code, the default answer is "keep the subscription until the numbers say otherwise." That doesn't mean Pro or Max is always the right plan. It means the first decision isn't a downgrade. The first decision is checking the credential. For the Pro-versus-Max question itself, see [Claude Pro vs Max: Usage Limits, Fable, and When Max Is Worth It](https://blog.laozhang.ai/en/posts/claude-code-pro-vs-max).

## What Current Official Sources Change: Max API Credits and Fable

Four boundaries decide which bill a Claude Code session lands on.

**Subscriptions and the API are separate bills, with one new exception.** Anthropic's help center puts it this way: "A paid Claude subscription enhances your chat experience, and the Claude API is billed separately." Pro does not include API usage through the Claude Console. Since October 7, 2026, Max and Team are the exception: Max 5x gets $100 and Max 20x $200 of monthly API credit, Team Standard seats $20 and Premium seats $100 (pooled and capped at $500 a month). You claim it after seven days on the plan by linking one Console organization. The credit is spent before any credit you bought, and unused credit expires each billing cycle. Free, Pro, and Enterprise aren't eligible.

**Claude Code can sit on either side.** Claude Code's authentication docs list the order it picks credentials in: a cloud provider setting first, then `ANTHROPIC_AUTH_TOKEN`, then `ANTHROPIC_API_KEY`, then `apiKeyHelper`, then a `CLAUDE_CODE_OAUTH_TOKEN`, and the subscription login from `/login` last. If you have an active subscription and `ANTHROPIC_API_KEY` is set, Claude Code uses the key once you approve it. A shell profile, IDE, or environment manager can quietly change who pays.

**Paid overflow isn't an API account.** Usage credits (Anthropic also calls them extra usage) let Pro and Max keep working after the included limits, at standard API rates, for Claude chats and Claude Code terminal usage. They're prepaid, can auto-reload, and take a monthly spend cap. While you're on credits, the prompt-cache lifetime drops from one hour to five minutes, so long pauses between turns cost more than on the plan. Credits don't turn a subscription into an API account for apps, CI, or service accounts. For the full credit math, see [Claude Extra Usage Cost: Credit Math and When Max Is Cheaper](https://blog.laozhang.ai/en/posts/claude-extra-usage-cost).

**Third-party tools and the Agent SDK have their own rules.** Anthropic's legal and compliance page for Claude Code says subscription OAuth is "designed to support ordinary use of Claude Code and other native Anthropic applications." Developers building products or services, including those using the Agent SDK, "should use API key authentication." Third parties may not "route requests through Free, Pro, or Max plan credentials on behalf of their users." The help article on the Agent SDK, updated October 7, says you can still use the Agent SDK, `claude -p`, and third-party apps with your subscription limits. The separate Agent SDK credit change planned for June 15 was paused, and "nothing has changed." Press reports from April 2026 said OpenClaw-type harnesses stopped drawing on subscription limits and moved to pay-as-you-go, bundles, or an API key, with a partial reversal reported later that month. Check your tool's own docs before you count on plan limits for it.

Three things are called "credits," and they don't mix:

| Name | Who gets it | What it pays for | What it doesn't pay for |
| --- | --- | --- | --- |
| Usage credits (extra usage) | Pro and Max subscribers who turn it on and prepay | Claude chats and Claude Code after plan limits, at API rates | API calls from your own apps |
| Max/Team monthly API credit | Max 5x, Max 20x, and Team, claimed into one linked Console organization | Claude API, Managed Agents, Agent SDK, Console playground; `claude -p` only with a key from the linked organization | Interactive Claude Code, the Claude apps, usage credits |
| Prepaid API credits | Anyone with a Console organization | All Claude API usage in that organization, including Claude Code run with that organization's key | Overflow on your Pro or Max plan |

## Price Anchors as of October 10, 2026

These are dated anchors, not permanent promises. Plan pages, help articles, and API docs change.

| Route | Price as of October 10, 2026 | Use it when | Watch out for |
| --- | --- | --- | --- |
| Pro | $20/month, or $200/year billed up front ($17/month equivalent) | One person uses Claude and Claude Code interactively and rarely needs Fable. | No API credit, and Fable only through usage credits. |
| Max 5x | $100/month (monthly billing only) | Pro limits interrupt valuable work, or you use Fable regularly. | Includes $100/month of API credit, which doesn't cover interactive Claude Code. |
| Max 20x | $200/month (monthly billing only) | You need much more session allowance. | Includes $200/month of API credit. Anthropic publishes no weekly multiple between the two Max tiers. |
| Team Standard | $20 per seat per month billed annually, or $25 monthly | A team needs seats, admin controls, and shared governance. | $20 of monthly API credit per seat, pooled and capped at $500. |
| Team Premium | $100 per seat per month billed annually, or $125 monthly | Seats for heavier users, with Fable on plan limits. | $100 of API credit per seat, inside the same $500 pool cap. |
| Usage credits | Standard API rates after included limits | A paid user needs controlled extra usage after the plan runs out. | Separate prepaid bill; set a monthly cap. |
| Usage bundles | $50 of credits for $45, $250 for $200, $1,000 for $700 | Heavy burst months where discounted overflow beats a bigger plan. | Up to $2,000 of bundles a month for individuals. |
| Claude API | Per-million-token prices by model, plus cache, Batch, and speed options | Apps, CI, agents, services, batch jobs, project-owned work. | Prepaid credits expire one year after purchase and aren't refundable. |

Web prices are in USD; Anthropic notes mobile pricing may vary, and some regions add tax at checkout. Anthropic doesn't publish message or token counts for any plan. Pro and Max have a five-hour session limit plus a weekly limit across all models, and Max 5x and 20x multiply the per-session allowance. The plan-by-plan detail is in [Claude Usage Limits by Plan: What 5x and 20x Actually Multiply](https://blog.laozhang.ai/en/posts/claude-usage-limits-by-plan).

Claude API prices per million tokens:

| Model | Input | Output | Cache hit | Batch input / output |
| --- | --- | --- | --- | --- |
| Fable 5.1 | $10 | $50 | $0.25 | $5 / $25 |
| Opus 5.5 | $4 | $20 | $0.20 | $2 / $10 |
| Opus 5, 4.8, 4.7, 4.6, 4.5 | $5 | $25 | $0.50 | $2.50 / $12.50 |
| Sonnet 5.5 | $2 | $10 | $0.10 | $1 / $5 |
| Haiku 5.5 (prompts up to 100K) | $0.10 | $0.50 | $0.01 | $0.05 / $0.25 |

Notes on the table:

- Opus 5.5 launched September 22, 2026, at prices Anthropic describes as "20% less than Opus 5." The older Opus versions stay at $5 and $25. For the version-by-version view, see [Claude Opus 5.5 Pricing and Limit Reset: What Each One Changes](https://blog.laozhang.ai/en/posts/claude-opus-5-5-pricing-limit-reset).
- Cache hits cost 0.1x base input on most models, 0.05x on Opus 5.5 and Sonnet 5.5, and 0.025x on Fable 5.1. Five-minute cache writes cost 1.25x base input ($5 for Opus 5.5). Batch is 50% off, and Batch and caching stack.
- Fast mode costs $8 and $40 on Opus 5.5 and $10 and $50 on Opus 5 and 4.8. It doesn't apply to Opus 4.6.
- Claude 4.6 and later models have no long-context surcharge: the full 1M context bills at standard rates. Haiku 5.5 prompts above 100K cost $0.50 and $2.50. US-only inference costs 1.1x.
- Sonnet 4.5 retires November 30, 2026.

Those API rows matter only for API-owned work, or for usage credits, which bill at the same rates. A subscriber's interactive session isn't billed per token, so pricing every turn by hand overstates what Pro or Max actually costs. An API project can look cheap in a toy example and then grow expensive once long context, retries, tool calls, and output volume arrive.

## Claude Code Route Diagnostic

Start every Claude Code cost audit with the active credential, not the invoice.

Run this inside Claude Code:

```bash
/status
```

Then inspect the environment that launched Claude Code:

```bash
if [ -n "${ANTHROPIC_API_KEY:-}" ]; then
  printf 'ANTHROPIC_API_KEY is set\n'
else
  printf 'ANTHROPIC_API_KEY is not set\n'
fi
```

Don't paste the key value into a chat, support ticket, screenshot, or issue. You only need to know whether a value is set.

These are the Claude Code API settings that decide the bill:

- **Interactive approval.** The first time Claude Code finds `ANTHROPIC_API_KEY`, it asks whether to use it and remembers the choice. To change it later, use the "Use custom API key" toggle in `/config`.
- **Non-interactive runs.** With `claude -p`, the key is always used when present.
- **Falling back to the subscription.** Run `unset ANTHROPIC_API_KEY`, then check `/status`.
- **Long-lived subscription tokens.** `claude setup-token` prints a one-year OAuth token for `CLAUDE_CODE_OAUTH_TOKEN`. It authenticates with your subscription and requires a Pro, Max, Team, or Enterprise plan.
- **Cloud sessions.** Claude Code cloud sessions always use your subscription credentials.

If `/status` shows the subscription and no key is in use, the problem is plan allocation, usage credits, or bundle settings, not an API leak.

| Question | Where to look |
| --- | --- |
| Which credential is Claude Code using right now? | Claude Code `/status` |
| Is the shell forcing API billing? | `ANTHROPIC_API_KEY` or `ANTHROPIC_AUTH_TOKEN` in the active environment, plus the `/config` toggle |
| How much plan allowance remains? | `/usage` in Claude Code, or Claude Settings > Usage |
| What did an API project spend? | Claude Console Usage/Cost or Billing |
| Has the Max monthly API credit been claimed and spent? | Claude Console Billing in the linked organization |

![Conceptual workflow checking Claude Code authentication, API-key presence, and the dashboard that owns billing](https://blog.laozhang.ai/posts/en/claude-api-vs-subscription-cost/img/billing-route-check.webp)

If your problem is a surprise API charge while you still have a subscription, the narrower guide is [Claude Code API Billing vs Subscription: Key, Credits, or Pro/Max](https://blog.laozhang.ai/en/posts/claude-code-api-key-vs-subscription-billing). If you're choosing among Pro, Max, Team, and usage credits, the [Claude Code pricing guide](https://blog.laozhang.ai/en/posts/claude-code-pricing-guide) covers the plan catalog.

## Scenario Math: Keep, Overflow, Or API

![Claude API versus subscription scenario breakeven matrix](https://blog.laozhang.ai/posts/en/claude-api-vs-subscription-cost/img/explainer-2.webp)

A good scenario calculation starts with the shape of the work, not averages.

For API-owned work:

```text
API monthly cost =
  input MTok * model input price
+ output MTok * model output price
+ cache write cost
+ cache read cost
- eligible Batch discount
+ fast-mode or US-only inference premium if used
+ retry, tool, and orchestration overhead
- Max or Team monthly API credit, if claimed
```

For subscription-owned work:

```text
Subscription monthly cost =
  plan or seat price
+ usage credits after included limits
  (or the bundle price, if you buy a bundle)
+ interruption cost when limits block valuable work
```

### Cost per Claude Code turn at API rates

The turn below is an assumption, not a measured average: 200K input tokens (a large repo context) and 20K output tokens. The cached column assumes 180K of the input is already in the cache, so it leaves out the first turn's cache-write cost.

| Model | No cache | 180K cached |
| --- | --- | --- |
| Opus 5.5 | $1.20 (0.2 × $4 + 0.02 × $20) | $0.516 (0.02 × $4 + 0.18 × $0.20 + 0.02 × $20) |
| Sonnet 5.5 | $0.60 (0.2 × $2 + 0.02 × $10) | $0.258 (0.02 × $2 + 0.18 × $0.10 + 0.02 × $10) |
| Fable 5.1 | $3.00 (0.2 × $10 + 0.02 × $50) | $1.245 (0.02 × $10 + 0.18 × $0.25 + 0.02 × $50) |

Your turns may be smaller or larger. Replace 0.2 and 0.02 with your own millions of input and output tokens, read from Console usage, to rerun the table.

### Break-even per plan with Opus 5.5

Divide the dollar gap by the per-turn cost:

| Comparison | Dollar gap | Uncached Opus 5.5 turns ($1.20) | Cached Opus 5.5 turns ($0.516) |
| --- | --- | --- | --- |
| API key only vs Pro | $20 | about 17 a month | about 39 a month |
| API key only vs Max 5x | $100 | about 83 a month | about 194 a month |
| API key only vs Max 20x | $200 | about 167 a month | about 388 a month |
| Pro plus usage credits vs Max 5x | $80 | about 67 a month on credits | about 155 a month on credits |
| Pro plus usage credits vs Max 20x | $180 | about 150 a month on credits | about 349 a month on credits |

How to read it:

- **API key instead of a plan.** The API only wins if your whole month at API rates stays under the plan price. With 22 workdays, Max 5x's 83 uncached turns come to fewer than four large Opus turns a day. Heavy interactive users run far more than that, provided the plan's limits hold.
- **Pro plus credits instead of Max.** If you'd spend more than about $80 a month on usage credits for this kind of turn, Max 5x is cheaper. Credits also lose the one-hour cache (five minutes on credits), so the cached column is optimistic for sessions with long pauses. Bundles stretch the threshold: with the $250-for-$200 bundle, $80 buys $100 of credit, about 83 uncached turns.
- **Fable on Pro.** Every Fable request on Pro is a credit charge. At about $3 per uncached turn, 27 large Fable turns a month cost more than the $80 gap to Max 5x, where Fable draws on plan limits instead.

### Max with automation: the monthly API credit changes the math

If you already pay for Claude API usage from scripts, the Agent SDK, or `claude -p` with a key, Max's monthly credit offsets it:

```text
Max 5x net cost  = $100 + max(0, API spend - $100)
Max 20x net cost = $200 + max(0, API spend - $200)
Pro net cost     = $20  + API spend
```

Example: Pro plus $150 a month of API automation costs $170. Max 5x costs $100 + $50 = $150, and you also get five times Pro's session allowance and Fable on plan limits. Max 20x costs $200. The offset holds only if you claim the credit into the Console organization your automation bills to, and the credit expires each cycle, so it doesn't carry over to a heavier month.

### Decision rule by usage pattern

- **Daily interactive Claude Code, mostly Opus or Sonnet.** Keep a subscription. Start with Pro if you rarely hit limits. Move to Max 5x when usage credits regularly pass about $80 a month.
- **Burst weeks once a month or less.** Stay on your plan and buy capped credits or a bundle for the spike. Don't rebuild the billing setup around one release week.
- **Regular Fable use.** Max. Pro bills Fable from the first request.
- **Light, irregular use.** A Console key on prepaid credits can be cheaper than Pro if a month at API rates stays under $20, which is about 17 large uncached Opus 5.5 turns.
- **Interactive work plus automation on one account.** Max, with the Console organization linked so automation spends the monthly credit first.
- **Backend app or CI pipeline.** API billing. Projects give spend limits, rate limits, usage reports, and a clean audit trail.
- **Team rollout.** Seats for people, API projects for automation. Assign Premium seats only to the people who need Fable or heavier limits.

## When API Is The Right Downgrade

The API is the better route for a heavy user only when the "Claude Code usage" is really an API-shaped workload.

Move to API billing when:

- the workload runs without a person steering each step
- the project needs API keys, spend limits, rate limits, and usage reports
- the work can be batched, cached, retried, or measured as token volume
- the organization needs project-level attribution
- the model mix and token volume are predictable enough to estimate
- you're building a product or service on the Agent SDK, which Anthropic's terms say should use API key authentication

Don't move to API billing when:

- you mainly work in long interactive terminal sessions
- the comparison ignores output tokens, retries, tools, and context growth
- the only evidence is a single `/usage` reading
- you haven't checked `ANTHROPIC_API_KEY`
- you're on Max and haven't claimed the monthly API credit yet
- you rely on Fable and would lose Max's included Fable allowance

If you do move work to the API, a few levers lower the bill without leaving Anthropic's own billing:

- Send work that can wait to the Batch API at 50% off.
- Cache repeated context; hits cost 0.05x input on Opus 5.5 and Sonnet 5.5.
- Use Sonnet 5.5 or Haiku 5.5 for steps that don't need Opus.
- On Max, let the monthly credit absorb the first $100 or $200.

For other ways to pay less, see [Claude Code Discounts in 2026: What's Live and the Cheapest Route](https://blog.laozhang.ai/en/posts/claude-code-discount).

API billing is excellent when the workload is software. It isn't a discount for every heavy human coding session.

## How To Avoid Double Paying

The expensive failure isn't only choosing the wrong plan. It's paying for both routes without noticing.

Use this monthly check:

1. In Claude Code, run `/status` and note whether the session uses your subscription or an API key.
2. In the shell or IDE profile, confirm whether `ANTHROPIC_API_KEY` or `ANTHROPIC_AUTH_TOKEN` is set, and check the "Use custom API key" toggle in `/config`.
3. In Claude Settings > Usage, check session and weekly pressure, usage credits, the monthly spend cap, and bundles.
4. On Max or Team, confirm the monthly API credit is claimed into the Console organization your automation actually uses. It's spent before purchased credit and expires at the end of each cycle.
5. In Console Usage/Cost or Billing, check API spend by project and model, and when prepaid credit expires (one year after purchase).
6. For API projects, confirm spend limits, rate limits, alerts, and owner labels.
7. For teams, keep human seats and automation budgets as separate lines in the monthly review.

If both subscription pressure and API spend are rising, don't buy more capacity blindly. First find out whether the same work is crossing over. A developer may have a subscription for interactive use while a local environment variable sends some Claude Code sessions to the Console. A team may buy seats for people while CI spends through an API project. Both can be legitimate, but they should be deliberate.

## FAQ

### Does a Claude Pro or Max subscription include API calls?

Pro doesn't. Since October 7, 2026, Max does in a limited way: Max 5x includes $100 and Max 20x $200 of Claude API credit each month, claimed into one linked Console organization. That credit covers API calls, the Agent SDK, and the Console playground, but not interactive Claude Code or usage credits. Everything beyond it is billed through the Console as usual.

### Should heavy Claude Code users downgrade from Max to API?

Usually not. At API list prices, $100 covers about 83 large Opus 5.5 turns (200K tokens in, 20K out) without caching, which a daily Claude Code user passes quickly. Downgrading also loses Max's included Fable allowance and the monthly API credit. Use the API for work that's automated or project-owned.

### Why do I see API charges if I have a subscription?

Check `/status` and `ANTHROPIC_API_KEY`. If a key is set and you approved it, Claude Code bills the API instead of your plan. With `claude -p`, a key in the environment is always used. Run `unset ANTHROPIC_API_KEY` or switch off "Use custom API key" in `/config`, then check `/status` again.

### Are usage credits the same as API credits?

No. Usage credits are paid overflow on Pro or Max after your plan limits, billed at API rates, and they pay for Claude chats and Claude Code. API credits live in a Claude Console organization and pay for API calls from your own code. Max's monthly API credit belongs to the second kind and can't be spent on usage credits.

### Are usage bundles a reason to avoid Max?

Sometimes. Bundles ($50 for $45, $250 for $200, $1,000 for $700) make overflow cheaper, which suits occasional spikes. If you'd spend more than about $80 a month on credits, Max 5x is still cheaper. It also adds Fable on plan limits and $100 of API credit.

### Does the Agent SDK monthly credit change the decision?

The separate Agent SDK credit planned for June 15, 2026, was paused, and Anthropic says nothing changed. As of the October 7 update, you can still use the Agent SDK, `claude -p`, and third-party apps on your subscription limits. Max and Team monthly API credits also cover the Agent SDK when it runs with a key from the linked Console organization. If you build a product on the Agent SDK, Anthropic's terms say to use API key authentication.

### How do I buy a Claude API key?

Creating the key is free. In Claude Console, go to Settings > API keys, create a key, and copy it, because it's shown only once. Then buy prepaid credits in Settings > Billing. Credits expire one year after purchase and aren't refundable. The full walkthrough is in [Claude API Key: How to Get One, Is It Free, and Safe Buying](https://blog.laozhang.ai/en/posts/claude-api-key-free-tier).

### Is there a free Claude API key?

There's no ongoing free tier. Anthropic says new users receive "a small amount of free credits to test the API" without naming an amount; third-party guides report about $5. Research programs grant API credits to qualifying researchers, and Claude for Startups has been paused since October 9, 2026. For Max subscribers, the monthly API credit is the closest thing to free API usage.

### What does "Claude Max or Pro is required to connect to Claude Code" mean?

The message names two ways in. You can subscribe to Pro or Max and sign in with `/login`, or use an API key from the Claude Console, which bills per token. Pro at $20 a month is the cheapest subscription that works. If you already pay for a plan, run `/status` to confirm which account and credential Claude Code is using.

### What if my team has both Claude Code users and agents?

Split ownership. Use seats for named people and API projects for apps, CI, scheduled agents, service accounts, and batch jobs. Team seats now add monthly API credit ($20 Standard, $100 Premium, pooled up to $500), so link the Console organization your agents bill to. Review both dashboards monthly so the same work isn't paid for twice.

## Sources as of October 10, 2026

- [Anthropic help: paid Claude subscriptions and API/Console billing are separate](https://support.claude.com/en/articles/9876003-i-have-a-paid-claude-subscription-pro-max-team-or-enterprise-plans-why-do-i-have-to-pay-separately-to-use-the-claude-api-and-console) for the subscription/API boundary.
- [Anthropic help: monthly API credits for Max and Team plans](https://support.claude.com/en/articles/17154008) for the October 7, 2026 credit amounts, eligibility, and limits.
- [Anthropic help: choose a Claude plan](https://support.claude.com/en/articles/11049762-choose-a-claude-plan) for Free, Pro, Max, Team, and Enterprise positioning.
- [Anthropic help: what is the Max plan?](https://support.claude.com/en/articles/11049741-what-is-the-max-plan) for Max 5x and 20x prices and session multiples.
- [Anthropic help: what is the Team plan?](https://support.claude.com/en/articles/9266767-what-is-the-team-plan) for Team Standard and Premium seat pricing.
- [Anthropic API pricing documentation](https://platform.claude.com/docs/en/about-claude/pricing) for model prices, caching, Batch, fast mode, and the free test credit.
- [Anthropic announcement of Claude Opus 5.5](https://www.anthropic.com/news/claude-opus-5-5) for the September 22, 2026 launch price.
- [Claude Code authentication documentation](https://code.claude.com/docs/en/authentication) for credential order, the API-key approval prompt, `/status`, and `claude setup-token`.
- [Claude Code legal and compliance page](https://code.claude.com/docs/en/legal-and-compliance) for OAuth and Agent SDK authentication rules.
- [Claude Code costs documentation](https://code.claude.com/docs/en/costs) for API-user token charges and subscription usage views.
- [Anthropic help: use Claude Code with your Pro or Max plan](https://support.claude.com/en/articles/11145838-use-claude-code-with-your-pro-or-max-plan) for subscription login.
- [Anthropic help: manage API key environment variables in Claude Code](https://support.claude.com/en/articles/12304248-manage-api-key-environment-variables-in-claude-code) for `ANTHROPIC_API_KEY` and `/status` checks.
- [Anthropic help: manage usage credits for paid Claude plans](https://support.claude.com/en/articles/12429409-manage-usage-credits-for-paid-claude-plans) for paid overflow after plan limits.
- [Anthropic help: buy usage bundles](https://support.claude.com/en/articles/14246112-buy-usage-bundles) for bundle prices and monthly caps.
- [Anthropic help: use the Claude Agent SDK with your Claude plan](https://support.claude.com/en/articles/15036540-use-the-claude-agent-sdk-with-your-claude-plan) for the October 7 update and the paused June change.
- [Anthropic help: Claude API prepaid credits and billing](https://support.claude.com/en/articles/8977456) for credit expiry and refunds.
- [Claude Console API key documentation](https://platform.claude.com/docs/en/get-api-key) for creating keys.
- [Claude API rate limits documentation](https://platform.claude.com/docs/en/api/rate-limits) and [Usage and Cost Admin API documentation](https://platform.claude.com/docs/en/manage-claude/usage-cost-api) for spend limits and organization-level reporting.