# AI provider spend limits compared: what actually stops

URL: https://infro.io/blog/provider-spend-limits-compared
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-10-21
Last modified: 2026-10-21
Last reviewed: 2026-10-21 (next review due 2026-11-20)
Topic: Cost and FinOps
Format: Comparison

> OpenAI and Anthropic enforce hard monthly spend limits on the account itself (OpenAI per organization and project, Anthropic per organization and workspace). The Gemini API pauses at a billing-account tier cap and offers an experimental per-project cap in AI Studio with about a ten-minute delay. Google Cloud, Azure and AWS budgets only alert; Google can disable billing through Pub/Sub, AWS can apply deny policies, and Azure and Bedrock quotas limit tokens per minute, not dollars.

Key takeaways:
- Only OpenAI, Anthropic and the Gemini API document limits that refuse requests on spend; Google Cloud, Azure and AWS budgets notify, and their quotas cap tokens per minute, not dollars.
- Every provider limit acts late: OpenAI says enforcement is not instantaneous, Gemini caps lag about ten minutes, and cloud budgets lag hours.
- No provider documents a dollar limit per ordinary API key; the smallest hard scope is an OpenAI project, an Anthropic workspace or a Gemini project.
- A provider limit reached by a thief stops your own traffic in the same scope, so put experiments, agents and production in separate projects or workspaces.
- Provider limits are the backstop for a stolen key used outside your gateway; gateway budgets cannot see that traffic.

**Which AI providers let you set a spending limit that actually stops requests?** As of 2026-10-21: OpenAI (hard limits per organization and per project), Anthropic (a tier cap plus your own limits per organization and workspace) and the Gemini API (a billing-account tier cap plus an experimental per-project cap). Google Cloud, Azure and AWS budgets only alert; their quotas limit tokens per minute, not dollars. Every one of these limits acts late, and none is set per ordinary API key.

Those limits matter most in the case nobody plans for. A provider key stolen from a repository, a laptop or a third-party tool is used directly against the provider. It never passes through your gateway, so no gateway budget, allowlist or alert sees it. What stops it is whatever the provider enforces on its own account. This comparison reads each provider's documentation, opened on the same day, for exactly that.

It is the provider-side companion to [LLM spend limits compared](https://infro.io/blog/llm-spend-limits-compared), which compares gateways. For how to set up the layers that bound a leaked key, see [how to cap the damage from a stolen AI key](https://infro.io/blog/cap-stolen-ai-key-damage).

## The four questions

For each provider, the same four questions:

1. **Does it refuse, or only notify?** A notification needs a person awake to act on it. A refusal works at 3 a.m.
2. **At what scope?** Organization, project, workspace, billing account, deployment. The smallest hard scope decides how small a blast radius you can engineer.
3. **How late does it act?** Every provider counts spend after the fact. The lag is the window in which a stolen key spends freely.
4. **What else stops when it trips?** A cap stops everything in its scope, including your own production traffic.

## OpenAI

OpenAI separates two things that are easy to confuse. A **spend alert** sends a notification and API traffic continues. A **hard limit** makes affected requests return `429`: `organization_spend_limit_exceeded` for the organization limit, `project_spend_limit_exceeded` for a project limit. Both can apply to the same request. Alerts stay active when a hard limit is added, so you can be warned before the cap[1].

Limits reset with the monthly cycle, or traffic resumes after you raise or remove the limit and the change propagates. On timing, OpenAI is direct: "Enforcement is not instantaneous, so recorded spend can slightly exceed the configured amount." The guide documents no per-key spend limit; the smallest hard scope is a project[1].

What this means for a stolen key: a project key in a project with its own hard limit can spend up to that limit, plus whatever lands during the enforcement lag. An organization-wide key with no project limit is bounded only by the organization limit.

## Anthropic

Anthropic has two layers. Each of the Start, Build and Scale usage tiers carries a monthly spend cap ($500, $1,000 and $200,000 on 2026-10-21; the Custom tier has none). When the organization reaches the tier cap, usage pauses until 00:00 UTC on the first of the next month, and requests return `429` of type `rate_limit_error` with `error_code` `enforced_spend_limit_reached` and no `retry-after` header, so automatic retries keep failing[2].

Below that, you can set your own organization limit (no higher than the tier cap) and a limit per workspace. When usage reaches a limit you set, requests return `400 invalid_request_error`, with a message naming the organization or workspace limit and when access resumes[2]. Workspace spend limits are set from the Workspaces page, with alerts at thresholds you choose; they cannot be set on the Default Workspace, and organization limits apply even if workspace limits add up to more[3].

Two details shape blast radius. Keys can be scoped to a single workspace, so a workspace limit bounds what a workspace key can spend. And the Claude Code workspace, which Anthropic creates when members sign in to Claude Code, is the only workspace that supports per-user monthly spend limits[3]. Anthropic's pages do not state how quickly a spend limit takes effect.

## Google Gemini API

The Gemini API (AI Studio keys on `generativelanguage.googleapis.com`) enforces a monthly cap per **billing account**, set by usage tier: $250 at Tier 1, $2,000 at Tier 2, and $20,000 to $100,000 or more at Tier 3 on 2026-10-21. Spend is aggregated across every linked project with the Gemini API enabled, and when the account reaches its tier cap, "service is paused for all projects linked to that billing account until the start of the next billing cycle"[4].

Since March 2026 you can also set a **project spend cap** in AI Studio, a monthly dollar limit per project that stays on until you change it[5]. Google labels the feature experimental and limited in scope, says caps are not available for invoiced (offline) accounts, and warns that billing data can take around ten minutes to process, so a project can go over its cap[4]. Google's announcement puts it plainly: "users are responsible for overages incurred during that period"[5].

## Google Cloud (Vertex AI and everything else)

Google Cloud budgets are alerts. Google's documentation says an alerts-only budget "doesn't automatically cap Google Cloud or Google Maps Platform usage or spending", that it may take several hours before the first notification, and that there is a delay between using resources and the costs reaching Cloud Billing[6].

There are two ways to turn alerts into a stop, both blunt:

- **Disable billing from a budget notification.** A budget can publish to Pub/Sub, and a Cloud Run function can call the Cloud Billing API to remove billing from the project. Google warns that this terminates all services in the project, that "resources might be irretrievably deleted", that recovery is not guaranteed, and that the setup "doesn't guarantee that you won't spend more than your budget"[7].
- **Lower API quotas.** You can cap requests per day or per minute on a billable API from its Quotas tab. Google notes that these caps "regulate individual API volumes rather than overall spending", that enforcement has a latency after a threshold is passed, and that short spikes are permitted[8].

## Azure OpenAI

Azure budgets notify. Microsoft's tutorial says: "Resources aren't affected, and your consumption isn't stopped." Cost data is typically available within 8 to 24 hours, budgets are evaluated against it every 24 hours, and emails normally go out within an hour of an evaluation. At subscription and resource-group scope a budget can call an action group, which can run automation[9].

The control in the request path is **quota**: tokens per minute assigned to each deployment, up to a limit per subscription, region and model. Over it, requests get `429` until the minute's counter resets[10]. That bounds the rate a stolen key can spend at, not the total; a deployment allowed a high rate can still spend for hours before a budget email arrives.

## Amazon Bedrock

AWS Budgets notify on actual or forecast cost. Budget information is updated up to three times a day, typically 8 to 12 hours apart, and AWS warns that you may incur costs beyond the threshold before you are notified[11]. A **budget action** can run automatically or after approval when a threshold is crossed: apply an IAM policy or a service control policy, or target specific EC2 or RDS instances[12]. A deny policy on the identity a key belongs to is the nearest AWS equivalent of a stop, and it fires on the same delayed data.

In the request path, Bedrock enforces **service quotas** per model and Region: tokens per minute (input and output combined), a cross-model maximum of tokens per day per account and Region, and requests per minute for some models[13]. Like Azure's, these bound rate, not dollars.

## Side by side

| Provider | Control | Smallest scope | Refuses or alerts | Documented lag |
| --- | --- | --- | --- | --- |
| OpenAI | Hard limit | Project | Refuses: `429` `project_spend_limit_exceeded` | "Not instantaneous" |
| OpenAI | Spend alert | Organization, project | Alerts only | Not documented |
| Anthropic | Tier cap | Organization | Refuses: `429` `enforced_spend_limit_reached` | Not documented |
| Anthropic | Your spend limit | Workspace (not Default) | Refuses: `400 invalid_request_error` | Not documented |
| Gemini API | Tier cap | Billing account | Pauses every linked project | About 10 minutes |
| Gemini API | Project spend cap (experimental) | Project | Stops the project | About 10 minutes |
| Google Cloud | Budget | Billing account, project, filters | Alerts; optional billing disable via Pub/Sub | Hours |
| Google Cloud | API quota | Project, per API | Refuses over the rate | "A latency period" |
| Azure | Budget | Management group to resource group | Alerts; action groups | 8–24 h data, evaluated every 24 h |
| Azure OpenAI | Quota (TPM/RPM) | Deployment | Refuses over the rate: `429` | Per minute |
| AWS | Budget and budget actions | Account, filters | Alerts; IAM or SCP deny | Updated up to 3 times a day |
| Amazon Bedrock | Service quotas | Model and Region | Refuses over the rate | Per minute, per day |

Table: From each provider's documentation on 2026-10-21. "Not documented" means the cited page is silent, not that there is no lag.

## Four things the table does not show

**No provider documents a dollar limit per ordinary API key.** The smallest hard scope is a project or workspace. To bound one key, give its workload a project or workspace of its own and put the limit there. Anthropic's per-user limits exist only in the Claude Code workspace[3].

**A limit reached by a thief stops you too.** Anthropic pauses the organization until next month at the tier cap[2]; the Gemini tier cap pauses every project on the billing account[4]. A stolen key that runs to the cap turns a billing incident into an outage of your own production traffic in the same scope. Separating experiments, agents and production into their own projects or workspaces, each with its own limit, keeps one leak from exhausting the room the others need. Whether a separate billing account is worth it for Gemini production traffic is a judgement for your team; the documentation only says the tier cap is account-wide.

**Lag is exposure.** Every provider counts spend after the fact. The shorter the lag and the lower the limit, the smaller the window. A monthly limit set at three times normal spend, with a ten-minute or multi-hour lag, still leaves room for a large bill.

**Rate limits are not spend limits, but they help.** Azure quotas and Bedrock quotas cannot stop a total, but a deployment or model quota set close to what the workload needs bounds how fast a stolen credential can spend while the budget data catches up[10][13].

> **Example: One stolen key, three account layouts**
> An illustrative company uses OpenAI for three workloads and finds a project key from its evaluation pipeline in a public repository. In layout A, every workload shares one project with no project limit, and the organization hard limit is set at $20,000 a month: the key can spend up to that, and when it does, production stops too. In layout B, the evaluation pipeline has its own project with a $1,500 hard limit: the key can spend about $1,500 plus whatever lands during enforcement lag, and production is unaffected. In layout C, the same project also has an IP allowlist: requests from the attacker's addresses fail before any spend. The numbers are invented; the shape is what each layout bounds.

## A provider-limit checklist

- [ ] Every provider account has a hard limit where the provider offers one: OpenAI organization and project limits, Anthropic organization and workspace limits, Gemini project caps where your account type allows them.
- [ ] Production, agents, evaluations and experiments live in separate projects or workspaces, each with its own limit.
- [ ] Limits sit above normal monthly spend with headroom, and below the amount that would hurt.
- [ ] Spend alerts fire well before each hard limit, to people who can act.
- [ ] On Google Cloud, Azure and AWS, budgets alert on forecast as well as actual cost, and the stop you would use (billing disable, a deny policy, a quota cut) is written down and rehearsed.
- [ ] Quotas on Azure deployments and Bedrock models sit near what each workload needs, not at the maximum granted.
- [ ] Someone reviews provider usage per key or per project weekly; see [how to detect traffic that bypassed your gateway](https://infro.io/blog/detect-gateway-bypass-provider-usage).

## Provider limits and INFRO budgets

INFRO is an AI control plane in front of the provider accounts you connect. Its [budgets](https://infro.io/docs/org/spend-controls) per organization, project, member and key are checked **before** the provider is called, and a request that does not fit is refused with `402`. That acts earlier than the provider limits above, because it does not wait for billing data, though it counts INFRO's estimate of provider cost rather than the provider's bill. But it governs only traffic that goes through INFRO.

A provider key stolen from anywhere, including from a platform like INFRO that holds customers' provider keys, can be used directly against the provider. Every INFRO budget, allowlist and alert is bypassed. For that case the provider's own limits, scoped keys, revocation at the provider and usage monitoring at the provider are the backstop, which is why this page exists. On the Business plan, INFRO's [reconciliation](https://infro.io/docs/cost/reconciliation) reads OpenAI's and Anthropic's own cost reports with a separate admin credential and, with usage access on, can name traffic on your provider keys that did not go through INFRO. Without usage access it reports that check as not done, never as clean.

Set the provider limit above the gateway's organization budget, so the gateway refuses first in normal operation and the provider limit only ever trips on traffic the gateway never saw.

## Questions

### Does OpenAI have a hard spend limit?

Yes. OpenAI lets you set a hard limit on the organization and on each project; requests over it return 429 with organization_spend_limit_exceeded or project_spend_limit_exceeded. Spend alerts are separate and do not stop traffic. OpenAI says enforcement is not instantaneous, so recorded spend can slightly exceed the limit.

### Can I set a spend limit on a single API key?

Not as a dollar limit at OpenAI, Anthropic or Google, according to their documentation on 2026-10-21. The smallest hard scope is an OpenAI project, an Anthropic workspace (other than the default one) or a Gemini API project. Give each workload its own project or workspace, or put a gateway in front that enforces per-key limits on the traffic it serves.

### Do Google Cloud budgets stop Vertex AI or Gemini spend?

No. Google says an alerts-only budget does not cap usage or spending. You can connect a budget to Pub/Sub and a function that disables billing on the project, but that shuts down every service in the project, may delete resources, and Google says it does not guarantee you stay under budget. The Gemini API in AI Studio has its own spend caps.

### Do Azure OpenAI quotas limit cost?

Only indirectly. Azure OpenAI quota is a tokens-per-minute and requests-per-minute rate limit per deployment, region and subscription. Azure budgets notify and, in Microsoft's words, do not affect resources or stop consumption.

## Sources

1. Spend limits — OpenAI. https://developers.openai.com/api/docs/guides/spend-limits (accessed 2026-10-21)
2. Rate limits — Anthropic. https://platform.claude.com/docs/en/api/rate-limits (accessed 2026-10-21)
3. Workspaces — Anthropic. https://platform.claude.com/docs/en/manage-claude/workspaces (accessed 2026-10-21)
4. Billing — Google. https://ai.google.dev/gemini-api/docs/billing (accessed 2026-10-21)
5. Giving you more transparency and control over your Gemini API costs — Google. https://blog.google/innovation-and-ai/technology/developers-tools/more-control-over-gemini-api-costs/ (accessed 2026-10-21)
6. Create, edit, or delete budgets and budget alerts — Google Cloud. https://docs.cloud.google.com/billing/docs/how-to/budgets (accessed 2026-10-21)
7. Disable billing usage with notifications — Google Cloud. https://docs.cloud.google.com/billing/docs/how-to/disable-billing-with-notifications (accessed 2026-10-21)
8. Capping API usage — Google Cloud. https://docs.cloud.google.com/apis/docs/capping-api-usage (accessed 2026-10-21)
9. Tutorial: Create and manage budgets — Microsoft. https://learn.microsoft.com/en-us/azure/cost-management-billing/costs/tutorial-acm-create-budgets (accessed 2026-10-21)
10. Manage Azure OpenAI in Microsoft Foundry Models quota — Microsoft. https://learn.microsoft.com/en-us/azure/foundry-classic/openai/how-to/quota (accessed 2026-10-21)
11. Managing your costs with AWS Budgets — Amazon Web Services. https://docs.aws.amazon.com/cost-management/latest/userguide/budgets-managing-costs.html (accessed 2026-10-21)
12. Configuring budget actions — Amazon Web Services. https://docs.aws.amazon.com/cost-management/latest/userguide/budgets-controls.html (accessed 2026-10-21)
13. Quotas for the bedrock-runtime endpoint — Amazon Web Services. https://docs.aws.amazon.com/bedrock/latest/userguide/quotas-runtime.html (accessed 2026-10-21)