On October 7, 2026, Anthropic added monthly API credits to Claude's Max and Team plans, which can be used to build and run your own apps and AI agents. According to the official release notes, the credits are rolling out over the next few days. Max plans receive $100 or $200 per month, and Team plans receive up to $500 per month depending on the number of seats.
For Max plans purchased on the web, that works out to API credits equal to the monthly fee. However, the credits can only be used on Claude Platform, Anthropic's developer service. They do not raise the usage limits for regular Claude chat or interactive Claude Code.
Using the Agent SDK under your subscription's usage allowance also remains available. To understand what this change actually means, you need to look at which kinds of usage the credits apply to and what API charges you would actually incur.
Max gets credits equal to the monthly fee; Team gets credits based on seat count
Max 5x receives $100 in API credits per month, and Max 20x receives $200.
On Team plans, each standard seat is allotted $20 and each premium seat $100, and these amounts are pooled into a balance shared across the organization. The same rules apply to the discounted Team plans for nonprofits and scientists, but Free, Pro, and Enterprise plans are not eligible.
Comparing the amounts listed in Anthropic's official help article with each plan's subscription price gives the following.
| Plan / seat | Regular subscription price | Monthly API credits |
|---|---|---|
| Max 5x | $100 per month | $100 |
| Max 20x | $200 per month | $200 |
| Team standard seat | $25 per month if billed monthly / $20 per month equivalent if billed annually | $20 per seat |
| Team premium seat | $125 per month if billed monthly / $100 per month equivalent if billed annually | $100 per seat |
Subscription prices are the pre-tax prices for plans purchased on the web. Prices may differ if you subscribed to Max through a mobile app. API credits on Team plans are also capped at $500 per month, regardless of the number of seats.
Pricing is based on the Max plan explainer and Anthropic's official pricing page.
For people who already subscribe to Max and also pay for API usage separately, the new credits may cover some or all of what they previously paid in API fees.
However, even though the credit amount matches the monthly fee, the Claude subscription itself is not being discounted. If you don't use the API, you won't benefit from the credits.
When signing up as a new subscriber, you should consider not only how much you will use the Claude app, but also how much API usage you expect each month.
Requirements for receiving API credits
To receive the API credits, you need to link a Claude Console organization from the billing settings on claude.ai.
New subscribers can apply seven days after joining an eligible plan. Subscriptions purchased through iOS or Android are also eligible, but linking must be done from a web browser.
The granted credits can be used without registering a credit card on Claude Platform.
Only the Max subscriber, or the Primary Owner or an Owner of a Team plan, can apply. You also need Owner, Admin, or Billing permissions in the Console organization you are linking.
This is not a system in which each regular Team member receives per-seat credits on their own account.
Claude Code is excluded, and claude -p depends on how it is run
The API credits can be used for the Claude API's Messages API and Message Batches API.
They also apply to the Playground in Claude Console, where you try out prompts, and to the Claude Agent SDK for building your own AI agents. They can also be applied to charges for Claude Managed Agents, where Anthropic provides the execution environment.
On the other hand, they cannot be used for interactive Claude Code in the terminal, IDE, desktop app, or web. They also cannot be applied to extra usage after you hit your Claude app usage limit, and use of Claude through external cloud services such as Amazon Bedrock and Google Cloud Vertex AI is not covered either.
One point deserves particular attention: non-interactive execution with claude -p.
This command passes an instruction to Claude and has it carry out the task, but which allowance the charges are deducted from differs depending on whether you use an API key from the linked Console organization or log in with your Claude subscription.
| How it is used | Treatment of these API credits |
|---|---|
| Calling the Claude API with an API key from the linked Console organization | Eligible |
Running the Agent SDK or claude -p yourself using the same API key |
Eligible. Billed as Agent SDK usage |
Logging in with a Claude subscription and using the Agent SDK or claude -p |
API credits are not used; consumes your subscription usage allowance |
| Running from the Claude Code GitHub Action, an IDE extension, or the Claude desktop app | Not eligible even with -p. Treated as Claude Code usage |
| Interactive Claude Code, extra usage in the Claude app | Not eligible |
| Claude Platform via AWS, Amazon Bedrock, Google Cloud, Microsoft Foundry | Not eligible |
In other words, you can't tell whether usage qualifies for API credits just from the fact that you are using Claude or running it non-interactively.
The pricing that applies depends on which Console organization's API key you use and which environment you run the process from.
The table above is based on the "Does this cover claude -p?" section of the official help article and the developer documentation.
The monthly API credits should also be distinguished from the Agent SDK usage terms announced in June.
On June 15, Anthropic explained that it was shelving a previously announced change to how the Agent SDK could be used.
The October 7 update of the same notice also states clearly that you can continue to use the Agent SDK, claude -p, and third-party apps under your subscription's usage allowance.
In short, the API credits do not replace existing flat-rate usage.
In addition to using your subscription allowance, you can now also keep extra costs down, up to a fixed amount each month, when running processes via API key on pay-as-you-go billing.
Even at the same $100, the number of runs varies widely by model
On October 7, Anthropic also announced a small AI model, Haiku 5.5.
Because the API credits apply to models available on Claude Platform, the amount of processing you can run for the same dollar amount varies greatly depending on the model you choose.
For example, for API calls with the same conditions of 20,000 input tokens and 2,000 output tokens, Sonnet 5.5's standard per-token price is 20 times that of Haiku 5.5, and Opus 5.5's is 40 times.
Calculating with the same number of input and output tokens, based on Anthropic's standard API pricing as of October 8, 2026, gives the following.
| Model | Per 1M input tokens | Per 1M output tokens | Estimated cost per call | Runs possible with $100 |
|---|---|---|---|---|
| Haiku 5.5 | $0.10 | $0.50 | $0.003 | About 33,333 |
| Sonnet 5.5 | $2 | $10 | $0.06 | About 1,666 |
| Opus 5.5 | $4 | $20 | $0.12 | About 833 |
The cost per call is calculated with the following formula:
(20,000 × input price + 2,000 × output price) ÷ 1,000,000
The number of runs is $100 divided by the cost per call, rounded down to the nearest whole number.
The calculation uses standard global pricing, and for Haiku 5.5 applies the rate for prompts of 100,000 tokens or fewer.
It also assumes that inputs, including instructions and conversation history, and outputs, including billable reasoning tokens, each stay within the token counts shown in the table.
However, these are theoretical counts calculated from the price list, not the number of tasks you could actually complete.
An AI agent may call the model many times before finishing a single job. If a process fails and is retried, token consumption rises accordingly.
This estimate also excludes discounts from prompt caching and batch processing, as well as additional charges for tool use. Charges based on Managed Agents runtime, surcharges for specifying a region, taxes, and fees for external services are also excluded.
Even so, it shows that there is a large difference in how many runs you get when using the same API budget for a high volume of routine tasks versus entrusting complex work to a high-performance model.
If a lower-priced model meets your quality needs, choosing it lets you run more processes.
On the other hand, choosing a model purely on low unit price can lead to more output corrections and retries, which may shrink the cost benefit.
Pricing also differs for Managed Agents and batch processing
When using API credits, not only the model's unit price but also how you run the process matters.
With Claude Managed Agents, in addition to regular token charges, a fee of $0.08 per session-hour applies while a session is running.
For processing that doesn't need an immediate response, using the Message Batches API cuts input and output token charges by 50%.
However, this batch discount does not apply to Managed Agents session fees.
Even for the same AI agent development and operation, the pricing structure changes depending on how it is run. To estimate how much processing the monthly credits can cover, you need to consider both the model choice and the execution method.
Team plans are capped at $500 per month, with the balance shared across the organization
On Team plans, API credits are calculated based on the type and number of seats you subscribe to.
For example, with 3 standard seats and 2 premium seats, the monthly credits would be:
$20 × 3 seats + $100 × 2 seats = $260
However, API credits granted on Team plans are capped at $500 per month for the entire organization.
That cap is reached with 25 standard seats alone, or with 5 premium seats alone.
In other words, beyond a certain size, adding seats no longer increases the API credits.
The number of seats on a Team plan is the number of subscriptions for employees and others to use Claude. It is not a system that lets you increase credits without limit to match the scale of app development or automated processing via the API.
Also, if you add seats mid-month, the corresponding API credits are reflected only from the next billing month.
The Anthropic developer documentation gives an example in which adding one premium seat to the $260 configuration above raises the amount to $360 from the next billing month.
Multiple Max subscriptions cannot be combined into one organization
There are also limits on where API credits can be received.
Each Claude plan can be linked to only one Console organization, and each Console organization can receive API credits from only one plan.
Therefore, API credits granted under multiple Max subscriptions cannot be pooled into a single Console organization.
Users also cannot change the linked organization themselves; to change it, you need to contact Anthropic support.
In a linked Console organization, all API keys and workspaces share the same credit balance.
For example, if you run a prototype app and a production app in the same organization, heavy API use by the prototype will also reduce the credits available to the production app.
You can separate workspaces by project and set spending limits, but individual API credits are not granted to each project.
When developing and operating multiple apps or agents, you need to manage consumption by workspace as well as the organization-wide balance.
Even with credits remaining, auto-reload may trigger charges
Monthly API credits are replenished according to your subscription's billing cycle, after the Claude plan payment is processed.
Even on annual plans, credits are granted monthly, and unused credits cannot be carried over to the next month.
The credits therefore are not designed for saving up several months' worth to run a large job all at once.
For API usage charges, the monthly credits granted this time are applied first, followed by credits you have purchased.
Even after you use up the granted amount, you can keep using the API as long as purchased credits remain. Once no available balance remains, API requests stop.
Normally, API usage charges are not automatically added to your Claude subscription fee. However, organizations that have a billing agreement through a sales representative are billed as usual for usage beyond the credits.
One thing to watch out for is the Claude Platform auto-reload feature.
If auto-reload is enabled, additional purchases may occur even when the API credits granted this time remain.
This is because auto-reload operates based on the balance of purchased credits, not the balance including monthly credits.
When purchased credits fall to the threshold you set, new credits may be purchased automatically even if monthly credits remain.
The official Anthropic documentation also states clearly that auto-reload can run while granted credits remain.
It is risky to assume that your card won't be charged until you have used up the free granted credits.
If you have auto-reload set up, you need to check both your purchased credit balance and your monthly credit balance.
Spending limits and credit refresh dates do not match
The API also has a monthly spending limit, separate from the credit balance.
This limit includes usage charges covered by the monthly credits granted this time.
The monthly spending limit resets on the 1st of each month, while API credits are replenished according to your Claude plan's billing cycle.
As a result, the day the spending limit resets and the day new API credits are granted do not necessarily coincide.
Rate limits, which restrict the number of API requests or tokens you can use within a given period, also continue to apply.
In other words, even with plenty of API credits remaining, spending limits or rate limits may prevent you from running processes when you want to.
You need to plan your operations around spending limits and rate limits as well as the credit balance.
How monthly API credits change the development of custom apps and AI agents
With this change, people who already use Claude's Max and Team plans will find it easier to keep API costs down when developing custom apps and AI agents.
The benefit of receiving a fixed amount of credits each month is especially large for prototyping, where the API is called repeatedly.
However, the granted credits do not directly lower the Claude subscription fee, nor do they raise the usage limits of interactive Claude Code.
The credits also expire, and unused amounts cannot be carried over to the next month. If you use them for continuous development or production operation, you need to keep track of your monthly API consumption.
Actual costs depend not only on the model you use but also on how many API calls an agent makes to complete a single job and how many corrections and retries occur.
If a low-priced model delivers sufficient quality, many processes can be run within the monthly credits. On the other hand, using a high-performance model for complex work may use up the granted amount in a short time.
These API credits can be seen as a way to ease the cost burden when starting to build your own apps and AI agents with Claude.
What matters is not increasing API usage to match the granted amount, but estimating the model and processing volume your work requires and judging how much of that cost the credits can cover.
If you make good use of the monthly credits, you should be able to iterate on prototypes and testing while keeping extra costs down, making it easier to move toward practical apps and AI agents.