AI API Spend Limits When You Bring Your Own Key

AI API spend limits are the monthly caps a model provider enforces on what its API may bill an organization, a workspace or a project. When Insulin runs on your own OpenAI or Anthropic key, the provider’s cap is the only one that sees the provider’s bill: Insulin’s monthly spending limit caps what Fours charges, not what the provider does.

---

“We run Insulin on our own OpenAI or Anthropic key. What actually caps the provider bill?” Finance and platform owners ask it once an organization brings its own key (BYOK), and the answer surprises teams that have already set Insulin’s monthly spending limit. That limit is real, but it sits on the other bill.

With your own key there are two bills. The provider “bills you directly for the tokens, under your own contract,” while Fours charges a flat fee per unit for routing, securing and metering each request (What Is Metered). Each bill has its own limit, set in a different place, and neither limit can see the other bill.

Whether to bring your own key at all is a cost and procurement decision. This post covers the governance after it: what each limit caps, what OpenAI and Anthropic do at theirs, what Insulin does when a capped key refuses a call, and a five-step setup.

What caps AI API spend when you bring your own key?

The provider’s spend limit caps the provider’s bill; Insulin’s monthly spending limit caps everything Fours meters. A BYOK organization needs both.

Two bills, separate limits

	Insulin’s monthly spending limit	Anthropic spend limits	OpenAI spend limits
Caps	All metered Insulin charges: the per-unit fee on your own key, Fours-hosted tokens, sandboxes and storage	Claude API spend for the organization, or for one workspace	API spend for the organization, or for one project
Set on	Settings → Billing, one limit per organization, $0 to $100,000 a month	Settings > Billing, or the workspace under Settings > Workspaces	Organization limits, or the project’s Limits
Warns before blocking?	No. It only blocks	Workspace alerts at spending thresholds	Spend alerts, which notify while traffic continues
When reached	AI requests pause for the rest of the month; sandboxes and storage keep working	HTTP 400, invalid_request_error	HTTP 429, organization_spend_limit_exceeded or project_spend_limit_exceeded
Stops you don’t set	A zero balance on pay as you go, and the debt limit Fours sets	The tier cap: $500 (Start), $1,000 (Build), $200,000 (Scale) a month, returning HTTP 429 with enforced_spend_limit_reached	The tier’s usage limit: $500 (Build), $5,000 (Launch), $200,000 (Grow) a month, returning organization_usage_limit_exceeded
Clears when	You raise or remove it, within about a minute, or the next month starts. Adding credit doesn’t clear it	You raise or remove it, or at the time its error states. The tier cap lifts at 00:00 UTC on the 1st	You raise or remove it and the change propagates, or the monthly cycle resets

What does Insulin’s monthly spending limit cover?

Insulin’s monthly spending limit is a ceiling on what your organization may spend with Fours in a calendar month, counted across every resource Fours meters (Payment, Limits, and Top-Ups): AI input and output tokens, sandbox processor, memory and storage, and object storage. On your own key, the token charge is Fours’ per-unit fee; on a Fours-hosted model, it’s the hosted rate.

Four properties matter once you bring your own key:

• It never sees the provider’s invoice. Tokens on your key reach it only as Fours’ per-unit fee.
• It blocks and never warns. The Billing FAQ asks “Can we set a limit that warns without blocking?” and answers “No.”
• It stops AI, not sandboxes or storage. Reaching it pauses AI requests, but running sandboxes keep running and new sandboxes and uploads still work, so their charges keep accruing. Adding credit doesn’t clear the limit; raising or removing it does, in about a minute.
• It isn’t an admin control. Settings → Billing “is not restricted to administrators, and there is no admin-only view within it.”

How do Anthropic’s spend limits work?

Anthropic enforces two kinds: a monthly spend cap set by your usage tier, and limits you set below it for the organization or one workspace. They fail differently (Rate limits):

• The tier cap, which Custom-tier organizations don’t have, pauses API usage “until 00:00 UTC on the first day of the next month, unless you request a higher limit sooner.” Requests return HTTP 429 with error type rate_limit_error, error code enforced_spend_limit_reached and no retry-after header.
• A limit you set returns HTTP 400 with error type invalid_request_error and a message beginning “You have reached your specified API usage limits”, or “specified workspace API usage limits” for a workspace, which states when access resumes.
• Workspace limits are set by selecting the workspace under Settings > Workspaces, where you can “cap monthly spending and configure alerts when spending reaches certain thresholds” (Workspaces). Two rules shape the setup: “You cannot set limits on the Default Workspace,” and “Organization-wide limits always apply, even if workspace limits add up to more.”

Anthropic’s own advice, written for subscriber credits, is the pattern recommended here: “To cap spending on a project, give it its own workspace and set that workspace’s spend limit.”

How do OpenAI’s spend limits work?

OpenAI’s hard spend limits are monthly caps on an organization or a project that make affected requests fail with HTTP 429; its spend alerts only notify. OpenAI’s changelog records both recent changes as shipped, not announced ahead: hard spend limits on July 22, 2026, and usage tiers cut “from five to three: Build, Launch, and Grow” on October 6, 2026.

• Hard limits. When tracked spend reaches one, “affected API requests return a 429 error with the organization_spend_limit_exceeded or project_spend_limit_exceeded code.” An organization limit covers every project; a project limit “applies only to API traffic billed to that project” (Spend limits). Setting one takes permission to manage the organization or project settings.
• Not instantaneous. “Recorded spend can slightly exceed the configured amount,” so leave headroom.
• Alerts only notify. “Spend alerts do not enforce a cap.” They stay active beside a hard limit, which is how you hear before it trips.
• The tier’s usage limit is separate. OpenAI approves a monthly usage limit for each paid tier, and an organization upgrades “automatically as its total credit purchases reach each threshold.”
• Resuming. Raising or removing a reached limit “allows traffic to resume after the update propagates. Otherwise, the limit resets with the next monthly cycle.”

What does Insulin do when your provider’s cap is reached?

Insulin treats the refusal like any failed model call: the turn moves to your next connected provider and, where your policy allows it, to Fours’ hosted models. In Insulin, “if a model call fails — a provider outage, a usage limit, or a rejected key — the turn retries on your next connected provider,” and “the Fours-hosted ones are the fallback the turn degrades to” (Model Selection). So a capped key stops the provider’s bill but not necessarily the work: the work can move onto Fours’ bill, where Insulin’s limit counts it.

Whether it should is set on Settings → Organization → AI Model Policy, which only an org ADMIN can change:

• Keep the fallback. The platform-key fallback switch is on by default; a non-empty allow-list must also include the hosted-model (DeepInfra) row. The provider’s cap stops the provider’s bill, the work carries on, and Insulin’s monthly limit caps what the fallback costs.
• Keep the work on your own keys. Turn the platform-key fallback switch off. Every AI call “must then use one of your own connected keys,” and an allowed provider with no connected key “fails closed rather than quietly falling back to Fours.” How Insulin’s AI model allowlist decides which providers serve a turn covers the rest of that tab.

When nothing is left to fail over to, the turn stops and says why; reading the card that stopped a reply explains each one. Retrying the capped key won’t help while the cap holds: Anthropic says retries fail “until access resumes,” and OpenAI says not to retry billing errors “that require you to take action.”

The organization’s cap governs organization agents, which use the providers the organization connected. The built-in Insulin assistant and personal agents use each member’s own connections and “never reach the organization’s keys,” and a member’s Anthropic connection is “Billed to the individual user.”

How do you set AI API spend limits for a BYOK key?

Give Insulin’s key its own workspace or project, make it a key no one person owns, cap and alert it at the provider, decide what it falls back to, and watch the signals Insulin gives.

1. Give the key its own Anthropic workspace or OpenAI project, so the provider’s figures for it are Insulin’s traffic alone. At Anthropic, that must be a workspace other than the Default Workspace, which can’t carry limits, and only organization admins can create one. At OpenAI, projects take “custom rate and spend limits per project.”
2. Use a key that isn’t one person’s. At Anthropic, “Personal keys are archived when their user is removed from the organization,” while “A service account key keeps working even if the user who created it is removed.” At OpenAI, administrators “can allow only service-account keys,” and OpenAI recommends an expiration date with “a regular key rotation process” (Production best practices). Plan rotations: Insulin doesn’t support editing the key, so changing it means deleting the integration and creating a new one, which takes an org ADMIN.
3. Cap and alert at the provider. Set the workspace or project limit and its alerts. On OpenAI, keep the hard limit below the true ceiling, since enforcement isn’t instantaneous.
4. Decide what a capped key falls back to, on AI Model Policy. Then set Insulin’s monthly spending limit to cover Fours’ side: the per-unit fee, any hosted fallback, sandboxes and storage. Agree who may change it, since Settings → Billing isn’t admin-only.
5. Watch the signals Insulin does give. API-key connections such as Anthropic and OpenAI “never show” the Connection expired state (When a connection expires), so a revoked or archived key shows up as failover: an italic note at the end of a reply naming both models. On Settings → Billing, the Usage panel grouped by provider puts tokens on your own keys beside the hosted models’, so a hosted share that grows after a cap is the fallback at work. Its costs are Fours’ bill; the provider’s invoice stays in the provider’s console.

Frequently asked questions

Does Insulin’s spending limit cap our OpenAI or Anthropic bill?

No. On your own key, the provider bills you directly for the tokens under your own contract. Insulin’s monthly spending limit caps Fours’ charges: the per-unit fee on your key, Fours-hosted tokens, sandboxes and storage. Cap the provider’s bill in the provider’s console.

What happens when our provider key hits its spend limit?

The provider refuses the call, and Insulin retries the turn on your next connected provider, then on Fours’ hosted models if your AI Model Policy allows them. With the platform-key fallback switch off, there is no hosted fallback, so the turn stops when nothing is left.

Can Insulin warn us before the monthly spending limit is reached?

No. The monthly spending limit blocks when it is reached and has no warn-only setting. For warnings on the provider’s bill, use the provider’s alerts: OpenAI’s spend alerts notify while traffic continues, and an Anthropic workspace can alert at spending thresholds you choose.

Who can change Insulin’s monthly spending limit?

Settings → Billing is not restricted to administrators, and there is no admin-only view within it, so the limit isn’t an admin-only control. Agree who may change it, and keep the hard cap at the provider, behind the provider’s own permissions.

Why does a capped Anthropic key return 400 instead of 429?

Anthropic separates its two caps. A spend limit you set returns HTTP 400 with error type invalid_request_error. Your tier’s monthly cap returns HTTP 429 with error code enforced_spend_limit_reached and no retry-after header. Both messages say when access resumes.

Does a zero Insulin balance stop requests on our own key?

Yes, on pay as you go. Fours’ flat per-unit fee is still owed on your own key, so a zero balance pauses BYOK requests too. Automatic top-up keeps the balance from reaching zero, and monthly billing is never stopped for a balance.

Takeaways

• Two bills, two limits. The provider’s spend limit caps the provider’s invoice; Insulin’s monthly spending limit caps every charge Fours meters, sandboxes and storage included.
• Put the hard cap at the provider, on a dedicated workspace or project with a key no one person owns. Insulin’s limit can’t see that bill, can’t warn, and isn’t admin-only.
• Decide what a capped key falls back to. By default the work can move to Fours’ hosted models and onto Fours’ bill; with the platform-key fallback switch off, it can move only to your other connected keys.
• Watch failover notes and the Usage panel by provider, because an API-key connection never shows Connection expired.

Before you set Insulin’s limit, see how each path is billed, with hosted models metered per token, your own keys at a flat platform fee, and sandboxes and storage the same either way, on Insulin pricing for hosted models and your own provider keys.