Since this was written, OpenRouter's model feed lists GPT-5.4 Mini in place of gpt-5-mini; GPT-5.4 Nano in place of gpt-5-nano.
How Anthropic's new linked billing works, what it costs you and your customers, what it will not do, and when to let a customer's own Claude organization pay for the AI your app runs
On November 17, Anthropic turned "paste your API key here" into a button.
Anthropic launched linked billing in beta on the Claude Platform: a customer links their own Claude organization to your app once, and from then on you choose, request by request, whether Anthropic bills the customer or you for the Claude usage your app generates - Claude API release notes. No API key changes hands. The customer approves the link on Anthropic's own page, sets a monthly spend cap for your app, and can unlink at any time from the Claude Console. Anthropic launched it with 19 platforms, among them Linear, Ramp, Railway, Warp, Asana and ClickHouse, and pitched it as billing infrastructure nobody has to build: "Anthropic hosts the approval flow and the billing, so there's no metering or invoicing to build" - Anthropic.
But it is not a consumer feature, and it is not a free lunch. Only organizations that pay Anthropic directly for API usage can be billed this way. Organizations billed through AWS, Google Cloud or Azure marketplaces are refused, and so are accounts that only hold a Claude subscription plan - Claude Platform docs. The monthly API credits that come with Claude Max, Ultra and Team plans cannot pay for these requests, batch requests cannot be billed to a customer, and a customer's own zero data retention and HIPAA arrangements do not follow the bill. Whether linked billing rescues your margins or adds a beta dependency you did not need depends on who your customers are, how much of your cost is inference, and how much of your product's value you were quietly charging as a markup on tokens.
This guide covers exactly how linked billing works under the hood, a working integration with code, the customer's side of the approval and the spend cap, the limits that decide which apps it suits, the money math of who carries a heavy user, the errors you must design for, how the launch partners actually use it, how it compares with every other way to make a customer pay for AI, and a decision framework. Everything here was verified against Anthropic's documentation and the live pages cited inline on November 20, 2026.
Linked billing is a beta. Endpoints, parameters and behavior can change, and the prices quoted here move often, so check the cited pages before you build on any single detail.
Contents
- What Anthropic Shipped on November 17
- Who Pays for Inference: The Structural Question
- How Linked Billing Works Under the Hood
- Build It: The Integration, Step by Step
- The Customer's Side: Approval, Spend Caps and Visibility
- What Linked Billing Will Not Do
- The Money Math: What a Customer's Usage Costs, and Who Carries It
- Errors and Fallbacks: Designing for the 402 and the 403
- Security and Data: No Shared Key Is Not No Risk
- How the Launch Partners Use It
- Linked Billing Against Every Other Way to Pay
- The Week Around It: Prices, an IPO and a Deadline Cluster
- Agents Change the Math
- Where It Fails: Risks and Open Questions
- A Decision Framework for Your App
Every Way to Pay for a Claude App's AI, Scored
Before going deep on linked billing, it helps to see it beside every other way an app can get its AI paid for. The table scores seven billing paths on the five things a founder actually trades off. Each cell carries the score and the fact behind it, and Sections 6, 11 and 14 hold the detail for every row. The scores describe a generic B2B software product; the paragraph under the table shows how to re-score them for your own customers, which changes the winner.
| # | Billing path | What It Does | Cost exposure (25%) | Buyer friction (20%) | Reach (20%) | Capability (15%) | Build and risk (20%) | Final |
|---|---|---|---|---|---|---|---|---|
| 1 | Developer pays (your own account) | You buy tokens and price them into your plans | 2 - every token is yours, including a heavy user's | 10 - the customer does nothing | 10 - every customer | 10 - every endpoint, Batches at 50% off, code execution | 8 - simplest build; the risk is margin, not security | 7.60 |
| 2 | Claude linked billing | Customer's Claude organization pays for requests you mark | 9 - customer pays list price; refused requests are never billed to you | 8 - one approval by an Admin or Billing member, cap set in the same flow | 4 - only organizations billed directly by Anthropic; marketplace and subscription-only accounts refused | 8 - Messages and Chat Completions; no Batches, no billable code execution | 5 - OAuth app, workload identity, user profiles, review; beta terms | 6.85 |
| 3 | Hosted Claude Code, user's own sign-in | End user signs in to the unmodified Claude Code binary you host | 10 - billed to the user under their own agreement | 6 - user signs in inside your agent's environment | 6 - anyone with a Claude plan or API key | 4 - only the unmodified Claude Code binary | 4 - may not intermediate; enforcement "without prior notice" | 6.30 |
| 4 | OpenRouter OAuth | User connects an OpenRouter account; its credits pay | 9 - "billed to their own OpenRouter credits" | 4 - needs an OpenRouter account with credits | 2 - mostly developers have one | 8 - many labs' models, Claude included | 8 - PKCE flow, no client secret, no approval gate | 6.25 |
| 5 | Sign in with ChatGPT | User's ChatGPT plan pays for eligible OpenAI calls | 9 - eligible requests draw on the user's plan | 9 - one click for an eligible subscriber | 5 - Plus and Pro subscribers only | 4 - OpenAI models only, no hosted tools | 2 - commercial apps go through an interest form | 6.05 |
| 6 | Customer's own API key (classic BYOK) | Customer pastes an Anthropic API key into your app | 10 - Anthropic bills the key owner | 3 - create an API account, add billing, copy a key | 4 - only customers with an Anthropic API account | 10 - the full API on their key | 3 - you store, encrypt and rotate customer secrets | 6.00 |
| 7 | Customer's own cloud credentials | Customer's Bedrock, Google Cloud or Foundry account serves Claude | 10 - the cloud provider bills the customer | 2 - cross-account roles or service accounts to configure | 5 - fits enterprises with cloud commitments | 7 - same models, but features vary by deployment | 4 - a second code path per cloud | 5.75 |
How to read the criteria. Cost exposure (25%) asks how much of the inference bill stays with you; a 10 means none. It carries the most weight because inference is the cost line that scales with your most enthusiastic customers. Buyer friction (20%) asks how many steps stand between a new customer and paid-for AI. Reach (20%) asks what share of a typical B2B app's customers can use the path today. Capability (15%) asks how much of the model surface you keep. Build and risk (20%) combines integration effort, the secrets you hold and your exposure to someone else's policy changes.
Re-score Reach for your own customers before you trust the ranking. The table puts developer-pays first because every customer can use it. If you sell to engineering teams that already run a Claude Platform organization billed directly by Anthropic (the buyers Linear, Warp and Factory serve), linked billing's Reach is closer to 9 than 4, and its score rises to 7.85, above developer-pays. If you sell to consumers, its Reach is effectively zero. That one variable decides more than any other, and Section 15 turns it into a decision.
1. What Anthropic Shipped on November 17
The release note is short. Anthropic launched linked billing "in beta with the user-profiles-billing-2026-10-01 beta header": customers "can now pay for the Claude usage in your app through their own Claude organization," and once a customer links, you "set billing_policy on each /v1/messages or /v1/chat/completions request to choose who pays" - Claude API release notes. In the Claude Console, customers can set a spend cap for your app or unlink it.
The announcement framed it for a specific kind of company. Linked billing exists so that "third-party platforms, such as coding agents and workflow automation tools, can let their end customers pay for Claude API usage without sharing an API key," and those customers "can then draw down from their existing Anthropic commitment, or pay as they go" - Anthropic. The phrase about commitments matters more than it looks, and Section 2 explains why.
The launch list reads like a map of where Claude spend already lives inside companies: Asana, ClickHouse, Factory, Gumloop, Harness, Higgsfield AI, Kilo Code, Linear, Major, Mintlify, Omni, OpenArt, Niteshift, Railway, Ramp, Runlayer, Tessera, Tines and Warp. Their quotes point at two motives. One is security: Runlayer's CEO Andy Berman put it as "No API key to share means one less attack vector," and Gumloop's CTO said customers "no longer hand their API key to a third party." The other is budget: Linear's Tom Moor said admins "can now use their committed Claude spend directly with the Linear cloud coding agent in a click," and Asana's chief product officer said customers can "use their existing Claude commitment to power Agentic Work Management in Asana" - Anthropic.
Anthropic's own illustration of the customer's view shows the shape of the product better than any description. A customer's Console gains a Linked platforms page listing each app it has linked, what each has cost this month, the share of the organization's total spend that went through linked apps, and the monthly cap the customer set for each one.
Look at the top row of that illustration: platform cost this month and share of total spend. Linked billing does not only move a bill. It shows every customer exactly what your features cost them in Claude usage, next to what every other linked app costs them. Section 14 comes back to what that transparency does to pricing.
Coverage outside Anthropic stayed close to the facts. The Next Web summarized it as letting "apps built on Claude bill API usage to a customer's own Claude organisation" and stressed the guarantee that matters most to a developer: "If Anthropic cannot bill the customer, the request is refused rather than charged to the developer" - The Next Web. No video walkthrough from Anthropic existed at the time of writing; the documentation and the partners' launch posts are the primary record, and this guide leans on both.
How to apply this section: treat linked billing as three things at once. It is a payment rail (the customer's organization pays Anthropic), a consent and control surface (the customer approves, caps and unlinks), and an attribution system (every billed request names the customer's user profile). Most integration mistakes come from building only the first.
2. Who Pays for Inference: The Structural Question
Every AI product has the same three parties: the customer who wants an outcome, the app that turns a request into model calls, and the lab that sells the tokens. Somebody has to pay the lab. Until now there were two ways to arrange it, and both had a structural flaw.
In the first arrangement, the app pays. It buys tokens on its own account and recovers the cost through its prices. That makes inference a cost of goods sold for the app, which works when usage is predictable and fails when one customer's agents run all night. A flat subscription priced for the median user is underwater on the heaviest ones, which is why so many AI products moved to credits and metering. Our guide to pricing an AI product against token costs works through that margin floor in detail.
In the second arrangement, the customer pays the lab directly by handing the app an API key. The cost leaves the app's books, but the key is a bearer secret with no scope, no cap the app respects by design, and no record of which app spent what. Linear's quote at launch was blunt about it: "Manually copying API keys is inherently insecure" - Anthropic. Finance teams also hate it, because every vendor holding a key means another line of Claude spend that nobody approved as a line.
Linked billing is a third arrangement: the customer pays the lab, but the app holds no secret. The customer grants a scoped, revocable permission on Anthropic's page, caps it, and sees it on their own Console. The app still sends the requests from its own organization, so it keeps control of the prompts, the model choice and the rate limits. Anthropic sits in the middle as the billing party for both sides.
Why Anthropic built it now
Start from where Anthropic's money comes from. Consumption-based revenue was $13.1 billion, or 80% of Anthropic's revenue in the first half of 2026, and more than 11,900 enterprise customers paid it $100,000 or more over the trailing twelve months as of September 30 - CNBC. Large customers like these often buy on committed spend: they agree to spend a set amount with Anthropic over a contract term. A commitment is only valuable to the buyer if it gets consumed, and a lot of Claude usage inside a company happens through vendors (a coding agent, a workflow tool, a data platform) that buy their own tokens. Every dollar of Claude a vendor buys on the customer's behalf is a dollar that does not draw down the customer's commitment, which can leave the customer paying for Claude twice: once in the commitment, and again inside the vendor's price.
Anthropic had already attacked that problem from the procurement side. In March 2026 it launched Claude Marketplace, where "enterprises can use a portion of their Anthropic spending commitments to finance purchases" of Claude-powered partner products, and Bloomberg reported Anthropic would not take a cut - SiliconANGLE. Linked billing is the self-serve, per-request version of the same idea. The marketplace today lists both paths side by side, under the filters "Buy with your commit" and "Link your billing" - Claude Marketplace.
The logic for Anthropic is straightforward once you see it as a channel problem. Linked billing turns every platform into a place where a customer's existing Anthropic relationship can be spent, keeps the billing relationship (and the visibility into which apps drive usage) with Anthropic rather than the vendor, and removes a reason for a buyer to route around Anthropic through a vendor's own token supply.
What it changes for the app
For the app, the change is less about cost than about what you are selling. Under developer-pays, part of your price was a resale of tokens, sometimes at a markup. Under linked billing, the customer pays Anthropic's list price directly for the requests you mark, while any subscription the app charges is billed separately by the app - Claude Help Center. The token markup disappears for those requests, and what remains is the value of your software: the workflow, the context, the integrations and the results.
That is the first-principles test for whether linked billing suits you. If your margin depends on reselling inference above cost, linked billing moves money out of your pocket. If your margin is crushed by inference you cannot price precisely, it moves a volatile cost line off your books and leaves you selling what you actually built. Most products sit between the two, which is why the per-request billing_policy exists: you can pass some usage through and absorb the rest.
The structural limit: half of Anthropic's revenue cannot link today
One number frames the reach problem. Customers buying through cloud marketplaces (AWS, Google Cloud and Microsoft Azure) accounted for 48% of Anthropic's revenue in the first half of 2026 - CNBC. Those organizations "can't be billed through this integration" today - Claude Platform docs. The share of revenue is not the share of customers, so this does not mean half of your buyers are excluded, but it does mean many of the largest Claude buyers, the ones with cloud commitments, cannot link yet. For them, the customer's own cloud credentials (row 7 of the table) remain the way to put Claude usage on their bill.
3. How Linked Billing Works Under the Hood
Linked billing is built from five pieces that already existed or launched in the weeks before it. Understanding each one prevents most of the integration surprises.
An OAuth app. You register your product in the Claude Console as an OAuth app, choose "Bill and link to organizations" as what it can do, and get a public client ID. Its name and logo are what the customer sees on the approval page. Anthropic does not issue client secrets for OAuth apps; your back end proves its identity another way - Claude Platform docs.
Workload identity instead of keys. Your back end authenticates to auth.claude.com with a client assertion: a short-lived JWT issued by your own identity provider, under a variant of the private_key_jwt method from RFC 7523. Workload Identity Federation accepts tokens from AWS IAM, Google Cloud, or "any standards-compliant OIDC issuer such as GitHub Actions, Kubernetes, SPIFFE, Microsoft Entra ID, or Okta" - Claude Platform docs. The assertion must carry exactly one audience and expire "no more than 1 hour after iat" - Claude OAuth reference. There is no static sk-ant- key anywhere in this design, on your side or the customer's.
An operator service account. Your app gets one non-human service account that is "authorized to send inference requests and attribute billing to the linked user profiles," and a service account can be the operator of only one OAuth app - Claude Platform docs.
User profiles. A user profile is a record in your own organization that represents one of your customers. Anthropic introduced profiles on October 20 so platforms could attribute requests to end customers - Claude API release notes. Their first purpose is safety: with a profile on each request, "a safety enforcement action, such as a restriction or a ban, can then apply to one end customer instead of your whole organization" - Claude Platform docs. Linked billing reuses them as the billing target. Within one app, connections are one to one: a customer's Claude organization links to only one of your profiles, and a profile links to only one organization.
A connection and a policy. When the customer approves, Anthropic creates a connection (an ocon_ ID) between their organization and your profile. From then on, each request you send with the anthropic-user-profile-id header and "billing_policy": {"type": "billing_policy", "bill_to": "user_profile"} is billed to the customer; a request with bill_to: "self" or without a billing policy is billed to you.
The linking handshake is a four-step exchange between the browser, your back end and auth.claude.com, numbered here the way Anthropic's documentation numbers it:
Read the diagram from the top. Step 5 is a pushed authorization request (PAR) from your back end that names the customer's user profile and returns a request_uri valid for 600 seconds. Step 6 redirects the browser to the approval page with only your client ID and that request_uri. Step 7 happens entirely on Anthropic's side. Step 8 exchanges a one-time code (single use, five-minute expiry) plus your PKCE verifier for the connection ID.
Two ways to authenticate billed requests
By default, your operator service account's own credential can bill every linked customer, as long as the request names the right profile. Anthropic calls this "operator-only tokenless authentication." For single-tenant deployments and customer-controlled sandboxes there is a stricter mode: the code exchange in Step 8 also returns a connection-bound access token that "can bill only that connection's customer" and expires within an hour, plus a refresh token lasting at most a year if you requested offline_access - Claude Platform docs. During the beta, whether requests with these tokens are enabled for your organization, and whether you can turn off the operator-only default, are both questions for your Anthropic account team.
Why it matters: the default mode makes one bug (a wrong profile ID in a header) into a billing incident for the wrong customer. Section 9 covers how to contain that.
4. Build It: The Integration, Step by Step
This section walks through a minimal integration in Python, adapted from Anthropic's own examples. It assumes your back end already authenticates as the operator service account through Workload Identity Federation, so ANTHROPIC_API_KEY must not be set in its environment.
The one-time setup has three parts, all done by someone with the Admin role in your Claude organization: create the OAuth app with "Bill and link to organizations" selected, set up client authentication against your identity provider, and create the operator service account with a second federation rule, then choose a default workspace for the app. Without a workspace, the code exchange is refused with unauthorized_client - Claude Platform docs.
The shared setup your code needs is small. The SDK exchanges your workload's identity token for an access token and refreshes it, so the client is constructed with no key:
import secrets
from urllib.parse import urlencode
import anthropic
import httpx
from anthropic.lib.credentials import IdentityTokenFile
from authlib.oauth2.rfc7636 import create_s256_code_challenge
AUTH = "https://auth.claude.com"
CLIENT_ID = "YOUR_CLIENT_ID" # from the OAuth app page in the Console
REDIRECT_URI = "https://app.example.com/claude/billing/callback"
JWT_BEARER = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer"
BILLING_BETA = "user-profiles-billing-2026-10-01"
client = anthropic.Anthropic() # authenticates as the operator service account
client_assertion = IdentityTokenFile() # your identity JWT, read fresh on each call
Step 4: create a user profile for each customer organization, once, and store its ID on the customer record. Creating a profile is not idempotent: "every create request makes a new profile, even with the same reference_id," so never create one on each linking attempt.
def create_user_profile(name: str, customer_id: str) -> str:
profile = client.user_profiles.create(
name=name,
external_user_details={"reference_id": customer_id},
)
return profile.id # "uprof_..."
If you resell API access rather than building a product on it, Anthropic asks you to send "access_type": "passthrough" when you create the profile; leaving it out creates an application profile, the right type for a product - Claude Platform docs.
Step 5: push the request when the customer clicks "Link your Claude organization." Generate a state value and a PKCE verifier, store both against the browser session, and send the request from your back end:
def push_authorization_request(user_profile_id: str) -> dict:
state = secrets.token_urlsafe(32)
code_verifier = secrets.token_urlsafe(64)
response = httpx.post(f"{AUTH}/v1/oauth/par", json={
"response_type": "code",
"client_id": CLIENT_ID,
"redirect_uri": REDIRECT_URI,
"scope": "billing:attribution",
"connection_type": "organization_shared",
"connection_auth_target": "platform",
"user_profile_id": user_profile_id,
"state": state,
"code_challenge": create_s256_code_challenge(code_verifier),
"code_challenge_method": "S256",
"client_assertion_type": JWT_BEARER,
"client_assertion": client_assertion(),
})
response.raise_for_status() # on an error, never redirect the browser
return {"state": state, "code_verifier": code_verifier,
"request_uri": response.json() ["request_uri"]} # valid 600 seconds
The scope must be exactly billing:attribution, or billing:attribution offline_access if you want refresh tokens for connection-bound auth. connection_auth_target must be platform, because inference runs in your organization even when the customer pays.
Step 6: redirect the browser to https://auth.claude.com/oauth/authorize with only client_id and request_uri in the query. Before you do, tell the user which account in your product they are linking and that the organization they pick on the next page is the one that pays. Anthropic's docs are explicit that the approval page "offers only the organizations of the Claude account that is signed in to the browser," and that your app cannot choose that account: prompt=select_account and login_hint do not change it - Claude Platform docs. A user signed in with a personal Claude account will not see their company's organization.
Step 8: handle the callback. Check state with a constant-time comparison, treat any error parameter as "no connection was made," and exchange the code immediately:
def handle_callback(par: dict, params: dict) -> str:
if not secrets.compare_digest(params.get("state", "").encode(), par ["state"].encode()):
raise ValueError("state does not match")
if "error" in params: # access_denied, user_profile_already_linked, ...
raise PermissionError(params ["error"])
response = httpx.post(f"{AUTH}/v1/oauth/token", json={
"grant_type": "authorization_code",
"code": params ["code"], # single use, expires in 5 minutes
"code_verifier": par ["code_verifier"],
"redirect_uri": REDIRECT_URI,
"client_id": CLIENT_ID,
"client_assertion_type": JWT_BEARER,
"client_assertion": client_assertion(),
}, timeout=10)
response.raise_for_status()
tokens = response.json() # store tokens now: the exchange returns them only once
return tokens ["connection_id"] # "ocon_...", store it on the customer record
Two details from the docs belong in your product copy. The response "does not identify which Claude organization the user linked," and a completed connection "does not guarantee that Anthropic can bill the customer," so Anthropic recommends wording the success message as "linked" rather than "billing active."
Then mark billed requests. Send the profile header, the beta header and the billing policy:
def message_billed_to_customer(user_profile_id: str, prompt: str):
return client.beta.messages.create(
model="claude-sonnet-5-5",
max_tokens=1024,
messages= [{"role": "user", "content": prompt}],
betas= [BILLING_BETA],
extra_headers={"anthropic-user-profile-id": user_profile_id},
extra_body={"billing_policy": {"type": "billing_policy", "bill_to": "user_profile"}},
)
To pay for a request yourself, omit billing_policy or set bill_to: "self". You can keep sending the customer's profile ID on requests you pay for, which keeps safety attribution intact.
Testing and publishing
A new app starts in testing, where only the test users you list (up to 10) can link, each with a monthly limit of $50 or less - Claude Help Center. You cannot link your app to the organization that owns it, so testing as a customer needs a second Claude organization of your own that is billed directly by Anthropic.
Publishing has two paths. If your organization has invoiced billing, the app goes live as soon as you confirm. Otherwise you prove control of your app's domain with a DNS TXT record and Anthropic reviews the app; DNS changes "can take up to 48 hours, so start before you need customers to link." If Anthropic does not approve, "you can't publish the app again yourself," and later changes to a live app's name, logo, homepage or redirect URIs send it back to review unless you have invoiced billing - Claude Platform docs. Plan the branding before you submit.
How to apply this section: budget for the identity work, not the billing work. The billing call is one header and one field. The work that takes days is the workload identity setup, the profile model for your customer records, and the product copy around the approval page.
5. The Customer's Side: Approval, Spend Caps and Visibility
Your customer never touches an API key. An administrator, someone with the Admin or Billing role in their Claude organization, clicks your button and walks through Anthropic's approval page: choose an organization (only if they have a choice), read a "How billing works" screen, set a monthly spend limit, and confirm on a last screen that lists what your app will be able to do. The connection "belongs to the whole Claude organization, not to the user who approved it," so it survives that person leaving the company - Claude Platform docs.
How the spend cap behaves
The spend cap is the part of linked billing your customers will care about most, and its rules are precise:
- The cap is monthly, in whole US dollars, per app. A customer can also set a default cap that applies to each linked app without its own cap; the apps do not share it.
- The approval page's amount field starts empty once your app is live, and the customer can continue without a limit. While your app is in testing, a cap of $50 or less is required.
- The smallest cap is $0, which refuses every request you bill to that customer, and there is "no practical maximum."
- When spend through your app reaches the cap, requests you bill to the customer are refused with a 402 "until 00:00 UTC on the first day of the next month or until the customer raises or removes the cap."
- The cap counts token costs and web search fees at list prices, before any negotiated discount, so "the customer's bill can differ from the amount that the cap counts."
- The organization's own monthly spend limit applies too, and whichever is reached first stops your requests.
All of those come from Anthropic's documentation - Claude Platform docs. The customer-facing help article adds two operational details: admins get emails at 80% and 100% of a limit (some organizations do not receive them), and the limit is not exact, since calls already in flight can finish - Claude Help Center.
What this means in practice is that the cap is a hard stop the customer controls and you cannot see. You "can't read a customer's cap or how much of it they have used." Your first signal that a customer hit it is a refused request.
What the customer sees afterwards
After linking, the customer manages everything from the Linked platforms page. Railway's launch post shows the real page with Railway linked: the access type ("Bill for inference"), the connection type, the link status, who approved it, what it has cost this month and the cap, above a default spend cap that applies to any linked platform without its own.
Note the "Preview" label beside Linked platforms in the Console's menu: the customer-facing surface is as new as the developer API. When a customer unlinks, new calls usually stop within about 10 seconds, and past usage stays in their Usage and Billing pages - Claude Help Center.
Anthropic's emails go only to the customer's admins and billing members, and not for every event. Anthropic emails when you exchange the code, when the customer unlinks and when your back end unlinks them, but not when you unlink a customer in the Console, and it "doesn't guarantee that an email is sent or delivered." Anthropic also leaves support with you: "You support your customers for everything about your app, including the Claude usage you bill to them" - Claude Platform docs.
How to apply this section: put the cap in your own onboarding copy. Tell the customer what a typical month of your product costs in Claude usage, so the number they type on Anthropic's page is informed rather than a guess that cuts your product off on the 12th of the month.
6. What Linked Billing Will Not Do
The limits matter more than the features, because they decide whether linked billing can carry your product or only part of it. They fall into five groups.
Who can pay
Only Claude Platform organizations that pay Anthropic directly can be billed. Prepaid credits and invoiced billing both count; cloud marketplace billing and subscription-only accounts are refused with 403 user_profile_not_billable - Claude Platform docs. Anthropic's help article lists the excluded subscription plans by name: "Claude subscription plans (Pro, Max, Ultra, Team, and Enterprise) can't be linked" - Claude Help Center.
That last point is the line between linked billing and OpenAI's Sign in with ChatGPT. Linked billing bills API organizations, the accounts engineering teams use to build on Claude. It does not let a consumer's Claude Pro or Max plan pay for your app, and Anthropic's Claude Code terms still say it "does not permit third-party developers to offer Claude.ai login into their own applications, or to route requests through Free, Pro, Max, or Ultra plan credentials on behalf of their users" - Claude Code docs.
Which credit can pay
Even an eligible organization may hold money that cannot pay. Credit bought in the Console pays, invoiced billing pays, but "the monthly API credits that come with Claude Max, Ultra, and Team plans" do not, and neither do credits from Anthropic's partner, VC and startup programs - Claude Platform docs. Those subscription credits are worth $100 a month on Max, $200 on Ultra and up to $500 pooled on Team - Claude Platform docs. A solo founder whose organization holds only that credit will link successfully and then see every billed request refused. Our guide to claiming Claude Max API credits covers what that credit can pay for instead.
Which requests
billing_policy works on /v1/messages and /v1/chat/completions. A request that bills the customer "can't use billable code execution features (the API returns a 400)," and Message Batches "doesn't currently support billing your customer": a batched request that sets bill_to: "user_profile" comes back errored and nobody is billed for it - Claude Platform docs. Anthropic's platform help article adds that Claude Managed Agents are not covered yet - Claude Help Center.
The batch exclusion is a real cost. Batches run at a 50 percent discount on input and output - Claude pricing. A product that does heavy offline work (nightly summaries, bulk classification, evaluation runs) either pays for that work itself at half price, or bills it to the customer at full price through synchronous requests. Code execution is billed by container time beyond a free allowance of 1,550 hours per organization per month, then $0.05 per hour per container, and it is free when used alongside web search or web fetch, which is why it stays on your side of the ledger.
Whose data terms apply
"Requests run in your organization, so your rate limits, model access, service tier, data retention, and encryption keys apply." The customer's own zero data retention, BAA and customer-managed keys do not apply, and Anthropic says plainly: "Don't link customers that need HIPAA, FERPA, or CMEK coverage for this usage" - Claude Platform docs. Model choice compounds this: Claude Fable 5.2 requires 30-day data retention and is not available under zero data retention at all - Claude API release notes.
What you can see
Usage reporting exists but is not a control system. The Console and the Usage and Cost Analytics API both report requests and tokens per user profile, including requests the customer paid for, but "neither shows what the customer paid or the customer's rates." The Console refreshes about once an hour and a request "can take a few hours to appear," so Anthropic warns: "Don't use these figures to stop a customer's usage at an amount that you choose." There is no webhook when a customer unlinks, and a successful response "doesn't say who was billed," so you keep your own record of which requests you sent with bill_to: "user_profile" - Claude Platform docs. On the cost endpoint, a customer-paid request adds 0 to amount and its list price to list_amount, which is the closest thing to a reconciliation field.
How to apply this section: list every place your product calls Claude, and mark each one as billable to the customer, billable only to you (batches, code execution, your own evals), or both. The first column is what linked billing can move. If it is small, linked billing is a feature for your enterprise tier rather than a new business model.
7. The Money Math: What a Customer's Usage Costs, and Who Carries It
Abstract arguments about margins become concrete with one worked example. Take an illustrative agent task, the kind a coding agent or a research agent runs for a customer: about 40 model calls whose prompts add up to 2 million input tokens, of which 1.8 million are read from the prompt cache and 200,000 are new tokens written to the five-minute cache, and 40,000 output tokens including thinking. The workload is an assumption for illustration; the prices are Anthropic's list prices.
At those prices, the task costs:
- Claude Haiku 5.5: cache reads at $0.01, cache writes at $0.125 and output at $0.50 per million tokens, about $0.06 (each call stays under the 100,000-token threshold where Haiku's higher long-prompt rates begin).
- Claude Sonnet 5.5: cache reads at $0.10, cache writes at $2.50 and output at $10, about $1.08.
- Claude Opus 5.5: cache reads at $0.20, cache writes at $5 and output at $20, about $2.16.
- Claude Fable 5.2: cache reads at $0.20, cache writes at $10 and output at $40, about $3.96.
The cache write prices come from the same rate card - Claude pricing.
Two things stand out. The spread between the cheapest and the strongest model is about 60 to 1 on the same task, so which model your product calls is the largest single input into what a customer pays. And caching dominates: on Sonnet 5.5, the 200,000 newly written tokens cost more than the 1.8 million cached ones. Our guide to cutting AI costs with prompt caching covers the mechanics.
One seat, three customers
Now put that task inside a product. Suppose you sell a seat at $40 a month and your agent runs on Sonnet 5.5. A light customer runs 10 tasks a month, a typical one 40, and a heavy one 150. Under developer-pays, inference costs you $10.80, $43.20 and $162.00 for those three customers, which leaves a gross margin on inference of $29.20, minus $3.20 and minus $122.00. Under linked billing for the same requests, inference costs you nothing, and each seat keeps its $40 for the costs you still carry (hosting, sandboxes, support).
On Fable 5.2, the heavy customer's 150 tasks would cost $594 a month. No flat seat price survives that under developer-pays, which is exactly why coding-agent companies moved to usage pricing in the first place. Linked billing is the cleanest version of usage pricing: the customer pays the lab's meter directly and caps it themselves.
What the customer's cap buys
Turn it around and look at the customer's spend cap. A customer who sets a $500 monthly cap for your app gets about 463 of these tasks on Sonnet 5.5, about 231 on Opus 5.5 and about 126 on Fable 5.2. That is the number to put in your onboarding, as Section 5 recommended, because a customer who types $100 thinking it is generous will run out in the first week on the strongest model.
What you give up
The money math is not one-sided. Under developer-pays you may have volume discounts or a commitment of your own that your customers' usage helps you reach; usage billed to customers does not obviously count toward it, and Anthropic's documentation does not say that it does. You also give up the markup on tokens for the requests you pass through, and the batch discount on work you could have batched. And a customer with negotiated rates pays their own rates, not yours: the cap counts list prices, while "the customer's bill can differ from the amount that the cap counts" - Claude Platform docs. For large customers that is often a better price than you could offer, which is part of why they want it.
How to apply this section: compute your own version of the seat chart with your real task shape and your real model mix. If your heaviest customer is underwater under developer-pays, linked billing (for customers who can link) or usage pricing (for everyone else) is not optional. Our walkthrough of metered billing for AI products covers the second.
8. Errors and Fallbacks: Designing for the 402 and the 403
The most important guarantee in linked billing is what happens when billing fails: "When a request sets bill_to: "user_profile", Anthropic either bills your customer or refuses the request. It never silently bills you instead" - Claude Platform docs. That protects your margin, and it turns every billing problem into a product problem you have to design for.
The errors you will meet, from Anthropic's list of expected errors:
| Status and code | What it means | Retryable? | What your app can do |
|---|---|---|---|
403 user_profile_not_billable | Anthropic can't bill this customer for this request, reason not given | Only in the first 10 seconds after a new connection | Check your credential and header, then ask the customer to link again or buy credits; or resend with bill_to: "self" |
402 linked_organization_spend_limit_reached | Cap or org limit reached, or no credit that can pay | No | Ask an admin to raise the cap or buy credits; or absorb with bill_to: "self" |
402 linked_organization_billing_unavailable | Organization can't be billed now (suspended, or credit ran out mid-reply) | No | Tell the customer to check their Claude account; or absorb |
503 overloaded_error | Anthropic couldn't confirm billability right now | Yes, with backoff and retry-after | Retry; the request was not served or billed |
400 user_profile_required | bill_to: "user_profile" without the profile header | Fix the request | A bug in your code |
On /v1/messages, the code is in error.details.error_code; on /v1/chat/completions you get the same status and message in OpenAI format without the code.
The product decision behind every refusal
Every 402 and 403 forces one decision: stop and ask the customer to act, or absorb the cost and serve the request yourself. The docs make both possible ("You can still serve the customer at your own cost by resending with bill_to: "self""), and neither is right everywhere. A coding agent mid-way through a two-hour task should probably finish the step on your bill and then pause. A bulk import of 10,000 documents should stop at once. A chat reply to a paying enterprise customer might always be absorbed up to a small allowance, so the product never looks broken because of a billing setting the user cannot see.
Here is a sketch of that policy in code. It is a pattern rather than Anthropic's sample: the error-code lookup follows the documented error.details.error_code location, and the absorb rule is yours to set.
BILLING_REFUSALS = {"user_profile_not_billable",
"linked_organization_spend_limit_reached",
"linked_organization_billing_unavailable"}
def call_claude(customer, request: dict, may_absorb: bool):
try:
return message_billed_to_customer_from(customer.profile_id, request)
except anthropic.APIStatusError as e:
details = ((e.body or {}).get("error") or {}).get("details") or {}
code = details.get("error_code")
if code not in BILLING_REFUSALS:
raise
log_refusal(customer, code, e.response.headers.get("request-id"))
if may_absorb and within_absorb_allowance(customer):
return message_billed_to_self(customer.profile_id, request)
notify_customer_admin(customer, code) # your own email: Anthropic's are not guaranteed
raise CustomerBillingBlocked(code)
Three rules from the docs belong in that code. Log "the whole error.message and the request-id response header of each refused request," because that ID is what Anthropic's account team needs to look up a refusal. Never treat a refusal as a decline by the user: the 403 has several causes the response does not distinguish, and "linking again fixes only some of them." And if you use connection-bound tokens, remember that such a token "can't send a request that you pay for," so the absorb path must authenticate as your operator service account.
Know the state before the request fails
You can read a customer's link status from your back end with the user-profiles-search-2026-08-30 beta header: connection_status.type is connected, disconnected (with last_revoked_reason, for example revoked_by_admin) or not_connected. But "connected doesn't promise that a request will succeed" - Claude Platform docs. Poll it for your billing settings page and your support tooling, not as a gate in front of each request.
Railway's implementation shows a good customer-facing pattern. When a limit is reached, its card reads Spend limit reached, agents try again on the next request, and members "can switch to a Railway model in the meantime" - Railway. The user always has a next step that does not involve finding a Claude admin.
How to apply this section: write the refusal policy before you write the integration. It decides your support load, your worst-case absorbed cost, and whether a customer's billing setting can break your product in front of their users.
9. Security and Data: No Shared Key Is Not No Risk
Linked billing removes the worst security pattern in AI products, the customer API key pasted into a vendor's database. It does not remove risk; it moves it.
The operator credential can bill everyone
In the default mode, Anthropic's docs carry a warning worth reading twice: "By default, your operator service account's own credential can bill every customer linked through this app. If a request with that credential names a different profile linked through this app, Anthropic bills that profile's organization, and no error tells you" - Claude Platform docs. A caching bug that serves customer A's profile ID on customer B's request is a silent billing incident.
The structural fix is to make the profile ID impossible to get wrong. Derive it from the authenticated tenant on the server, never from anything the client sends, and keep the mapping in one function that every Claude call goes through. Railway describes exactly this: "Every request to a Claude Platform model goes through a check before it leaves Railway, to make sure it's targeting the correct organization for billing. If that check fails, Railway doesn't send it" - Railway. Where your account team enables it, connection-bound tokens and turning off operator-only authentication make the mistake impossible at Anthropic's end rather than yours.
You are also responsible for honest use. "Set bill_to: "user_profile" only on requests the customer directs you to make... Don't bill a customer for your own usage, such as testing, evaluations, or work for other customers. The Claude API can't check this for you, so it's your responsibility." That sentence is a contract obligation in practice: the Linked Billing Terms you accept at publishing time sit on top of Anthropic's commercial terms.
Sandboxed agents get only the access token
For products that run agents in sandboxes, Anthropic documents a tight pattern. Give a sandbox "only the access token, never the refresh token"; decide which customer a sandbox serves "from the sandbox's own identity, such as its pod identity, and never from a value that the sandbox sends"; and make sure the sandbox cannot obtain a JWT matching your federation rules, with "no mounted identity token and no access to a cloud metadata server." Claude Code, the Claude Agent SDK and the Anthropic SDK can read the token from a credentials file in a configuration profile, and every other credential in the sandbox (ANTHROPIC_API_KEY, ANTHROPIC_AUTH_TOKEN, CLAUDE_CODE_OAUTH_TOKEN, an apiKeyHelper) must be unset because each can take precedence - Claude Platform docs.
This matters because the agent in the sandbox runs code the model writes. A sandbox holding a refresh token or a federation-eligible identity could mint credentials for other customers. Our guide to giving an AI agent an identity rather than an API key covers the broader pattern.
Data stays under your terms, and enforcement under your profile
Because requests run in your organization, your retention settings govern customer-paid traffic. That is simpler for you and a compliance question for the customer: their security team needs to know that linking does not extend their ZDR or BAA to your product. Say so on your billing page rather than letting them discover it in a review.
User profiles also limit how far a safety problem spreads. Anthropic runs automated classifiers over API traffic, and "without a profile on the request, one end customer can trigger an enforcement action that applies to your whole organization" - Claude Platform docs. Enforcement is not hypothetical: Anthropic's IPO filing estimated that 5% to 7% of revenue in the nine months to September came from customers later found in violation of its policies or terms, as our analysis of Anthropic's S-1 details. Sending profiles on every request, billed or not, is cheap insurance. On billed requests you can also set metadata.user_id to an opaque identifier for the individual person, which "helps Anthropic detect misuse by one person."
A practical identity note
Workload Identity Federation is the part of linked billing small teams underestimate. Unless you upload its key set inline, your issuer must publish its keys over HTTPS on port 443 at a public hostname, and the client assertion must expire within an hour of issue. Some hosting platforms issue OIDC tokens to serverless functions, Vercel among them, but check the details against Anthropic's rules before you plan on one: Vercel's function tokens have "a Time to Live (TTL) of two hours" - Vercel, longer than the one-hour maximum Anthropic accepts for a client assertion. A small back-end service that mints its own short-lived token, or a Kubernetes projected token with a short expiry, may be the simpler route.
10. How the Launch Partners Use It
The launch partners' own documentation shows patterns that a spec cannot. Read across them and three designs repeat.
Railway links a Claude organization to a Railway workspace, and Anthropic then bills that organization "for Claude API usage in Railway Agent, Cloud Agents, and the Slack and Discord bots, on your existing terms." API keys remain supported, and when a teammate has configured their own key as their default, "their usage goes to their key, and everyone else's goes to the linked organization." Linking takes a Railway workspace admin to start the flow and an owner, admin or billing admin of the Claude organization to approve, "often that's the same person" - Railway.
Linear uses it for its cloud coding agent, and its docs show where the line between the lab's bill and the vendor's bill falls. "If you connect your own provider API key (BYOK) or link a Claude organization, your provider bills model usage directly," but "sandbox runtime still uses Linear AI credits," billed in five-minute increments from $0.03125 for a small sandbox to $0.25 for an extra-large one - Linear. Inference moves to the customer; compute stays with the vendor.
ClickHouse covers "all Claude model usage across ClickHouse Cloud products, such as ClickHouse Agents," and adds two notable rules: without a link, Claude models in ClickHouse Cloud are served from Amazon Bedrock, and once linked billing is enabled, "only Claude models are available in ClickHouse Cloud." It is also unavailable for ClickHouse organizations with HIPAA or PCI DSS compliance enabled - ClickHouse.
Mintlify offers it to Enterprise customers whose contract includes bring your own model, with one link covering its assistant, agent, Autopilot and automations - Mintlify. Kilo Code put a "Claude (linked billing)" card on its existing bring-your-own-key page, and says it covers Claude usage across Kilo Desktop, Cloud Agents and the CLI, alongside the more than 500 models Kilo routes between - Kilo. Warp describes the same four steps (link, approve and set limits, Anthropic bills, unlink anytime) for its supported linked billing features, without listing which ones - Warp.
Three patterns run through all of them. First, linked billing sits beside BYOK, not in place of it: every partner kept API keys. Second, inference moves and compute stays: sandboxes, hosting and the vendor's own features remain on the vendor's bill. Third, it lands in the enterprise tier first: Mintlify gates it by contract, ClickHouse by compliance settings, and the quotes talk about commitments and admins. Nobody launched it as a consumer feature, because the eligibility rules make that impossible.
The ClickHouse rule deserves a second look. A product that routes between labs has to decide what "linked" means for a request that would have gone to another model. ClickHouse answered by restricting the organization to Claude models once linked; Kilo kept its multi-model router and added Claude as one billing source. Both are defensible. What is not defensible is silently sending a linked customer's request to a non-Claude model on your own bill and calling the feature "bring your Claude."
11. Linked Billing Against Every Other Way to Pay
Linked billing is one of several ways to make a customer, rather than you, pay for the AI your product runs. Each of the alternatives in the scored table fits a different customer.
Developer pays
Paying yourself is still the default for good reasons: nothing to explain, every endpoint available (Batches at half price, code execution, every beta), and every customer served. Its weakness is the one Section 7 drew: a heavy customer on a flat price. The usual fixes are usage pricing, credits and routing work to cheaper models, which our guide to cutting AI agent costs with model routing covers. With linked billing available, developer-pays becomes the fallback path inside a hybrid design rather than the only path.
The customer's own API key
Classic bring-your-own-key gives the customer the full API on their own account, including batches and code execution, which linked billing does not. The cost is that you hold a long-lived bearer secret for every customer, and the customer has no per-app cap unless they create a separate workspace for you. Anthropic's commercial terms permit it ("to power products and services Customer makes available to its own customers and end users") but not reselling the services "except as expressly approved by Anthropic" - Anthropic. Every launch partner kept it alongside linked billing, which says it still has a place: technical customers, workloads linked billing cannot carry, and organizations that do not meet the eligibility rules.
The customer's own cloud credentials
For enterprises that buy Claude through AWS, Google Cloud or Azure, the customer's own Bedrock, Google Cloud or Foundry credentials are the way to put usage on their bill and their cloud commitment. Anthropic's Claude Code terms name exactly these "3P inference provider" credentials as acceptable for end users - Claude Code docs. The trade-off is features: some endpoints differ by deployment, and Amazon Bedrock and Google-managed Google Cloud "don't have the /v1/user_profiles endpoints" - Claude Platform docs. Given that cloud marketplaces carried 48% of Anthropic's first-half revenue, a serious enterprise product probably needs this path as well as linked billing.
Hosted Claude Code with the user's own sign-in
If your product hosts Claude Code itself (a cloud coding sandbox, an agent runner), Anthropic's rules already allow the end user to bring their own billing, and in fact require it: platforms "may not pay for, resell, or intermediate Claude usage on their end users' behalf," and "each end user must authenticate with their own Anthropic API key, Claude subscription plan credentials, or 3P inference provider credential," with the binary unmodified - Claude Code docs. Linked billing's sandbox pattern, where a connection token is written into a Claude Code credentials profile, gives these platforms a cleaner version for organization customers.
The same rule is why tools that run the coder on the user's own machine bill the user's own plan. Founden's desktop app works this way when it builds a company: it runs Claude Code or Codex on the founder's own Mac against the founder's own Claude or ChatGPT subscription, and strips vendor API keys from the coder's environment so a build cannot quietly fall back to API billing. That is a different job from linked billing (it pays for building the product, not for the product's own AI once it has customers), and the two fit together: build on your own plan, then let your customers' organizations pay for what your product runs.
Subscription use carries policy risk. On April 4, 2026, Claude Pro and Max subscribers lost the ability to use their plan limits through third-party agent frameworks such as OpenClaw - The Next Web. In June, Anthropic paused a planned change that would have moved the Agent SDK, claude -p and third-party apps onto a separate monthly credit, telling reporters "Nothing changes for now" - The Decoder. Linked billing, built on API organizations with explicit terms, is the more stable foundation for a business.
Claude Marketplace purchases
Claude Marketplace is not a way to bill inference; it is a way to sell your product to a customer who pays from their Anthropic commitment. The marketplace describes it as paying "for partner platforms with budget you've already approved," and says buying through it is in limited preview - Claude Marketplace. Four of the 19 linked billing partners (Asana, Harness, Factory and Higgsfield AI) offer both. For a vendor selling to large Claude customers, the two paths answer different questions: linked billing pays for the tokens, the marketplace pays for the product.
OpenRouter OAuth
OpenRouter's PKCE flow lets a user connect their own OpenRouter account, after which "their requests are billed to their own OpenRouter credits" - OpenRouter. It reaches Claude and many other labs through one API with no approval gate, and the app can prefill a credit limit for the key it receives (the user can change it). Its weakness is reach: most of your customers will not have an OpenRouter account.
Sign in with ChatGPT
OpenAI's version targets consumers rather than API organizations. Since September 29, a Plus or Pro subscriber can grant an app the chatgpt.tokens.use.direct scope, and eligible requests then draw on their plan; the user sets a weekly cap per app as a percentage of their plan usage, and OpenAI's documentation for plan usage "is written for open-source and locally hosted apps," with commercial products pointed to an interest form - WorkOS. Plan-funded requests cannot set temperature and lose hosted tools such as file search and Code Interpreter. Our full guide to Sign in with ChatGPT covers the integration.
The contrast is the most useful frame for the whole market. OpenAI made the consumer's subscription portable; Anthropic made the organization's API account linkable. Google has published neither: a July 2026 thread on Google's own developer forum asking whether a sanctioned program for third-party subscription access is planned received no official answer before it closed - Google AI Developers Forum. For a consumer app, OpenAI's route is the only lab-backed one. For a B2B app selling to engineering teams, Anthropic's is the more complete: hosted consent, per-app caps, invoiced billing, enterprise commitments.
12. The Week Around It: Prices, an IPO and a Deadline Cluster
Linked billing landed in the middle of the busiest week of the year for builders, and three of the week's other events change how it should be used.
Prices reset around the same rate cards
Linked billing passes Anthropic's list price straight to the customer, so the price of the model you choose becomes a number your customer sees on their Linked platforms page. The top of the market reset within eight days. Anthropic released Claude Fable 5.2 on November 9 at $8 per million input tokens and $40 per million output tokens - Claude API release notes. On November 17, the same day as linked billing, OpenAI launched GPT-6.2 Astra and GPT-6.2 Sol - OpenAI API changelog. Astra lists at $8 input and $40 output - OpenAI model docs. That is down from GPT-6 Astra's $10 and $50 - GPT-6 Astra model page. Sol stays at $2 and $10, the same rate card as Claude Sonnet 5.5's $2 and $10.
Google completed its Gemini 4 line on the same timetable. Gemini 4 Hydrogen went generally available on November 12 at $1.50 and $7.50 with a free tier, and Gemini 4 Neon followed on November 18 at $3 and $15 - Gemini API changelog. Gemini 4 Carbon and Argon are at $2 and $10 through November 30 and rise to $4 and $20 on December 1 - Gemini API pricing. Our comparison of Claude Fable 5.2 and Gemini 4 Carbon works through what those prices mean per finished task.
The implication for linked billing is direct. When the customer pays, routing every request to the strongest model is no longer a cost you absorb but one your customer sees and caps. A product that routes well (Haiku for classification, Sonnet for most work, Fable only where it earns its price) will look cheap on the customer's Linked platforms page next to one that does not.
Anthropic is now a public company
Anthropic priced its initial public offering on November 18 at $83.00 per share for 980 million shares of Class A common stock, began trading on the Nasdaq Global Select Market under the symbol ANT on November 19, and expected the offering to close on November 20 - Anthropic. For builders, a public Anthropic means quarterly reporting on exactly the revenue lines linked billing touches: consumption revenue, enterprise commitments and the share that flows through cloud marketplaces. Expect the billing products to keep moving toward whatever grows those lines.
The deadline cluster
Three deadlines arrive before mid-December. Anthropic retires Claude Sonnet 4.5 on the Claude API on November 30, with Sonnet 5.5 as the named replacement - Claude Platform docs. Fast mode for Claude Opus 4.8 is removed the same day - Claude API release notes. OpenAI deprecates Agent Builder, puts the Evals platform into read-only mode and retires reusable prompt objects on November 30, then shuts down gpt-5, gpt-5-mini, gpt-5-nano and o3 on December 11 - OpenAI. If you are integrating linked billing this month, do the migration at the same time: a customer who links and immediately sees failed requests on a retired model will unlink faster than one who never linked. Our Claude 5.5 migration guide lists the breaking changes.
13. Agents Change the Math
Linked billing arrived as AI products shifted from chat replies to agents that work for minutes or hours. That shift changes which of its features matter.
Agent cost varies by design. A chat reply costs a fraction of a cent to a few cents. An agent run is the illustrative task from Section 7 multiplied by however long the agent decides to work, and the variance between runs is large. That variance is precisely the cost a vendor cannot price into a flat seat and a customer cannot predict without a cap. Linked billing's per-app monthly cap is the first control that sits with the customer, on the lab's own meter, for agent work a vendor runs. Our guide to letting an AI agent spend money safely covers the broader question of budgets for autonomous software.
Sandboxed agents are a first-class case. Anthropic's documentation includes a full section on running an agent in a sandbox with a connection-bound token written into a credentials profile that Claude Code, the Agent SDK and the Anthropic SDK read, with the agent re-reading the file "in the last 2 minutes before expires_at, and after a 401 response" - Claude Platform docs. Railway's cloud agents, Linear's coding agent and Factory's agents are this shape. If you run Claude Code for customers, this is the pattern that lets their organization pay without your sandbox ever holding a long-lived secret.
The gaps are agent-shaped too. Billable code execution cannot be billed to a customer, Message Batches cannot, and Claude Managed Agents are not covered yet. An agent that runs code in Anthropic's container, or a product built on Managed Agents, keeps those costs on its own bill. Expect those gaps to be the next things Anthropic closes, because they are where agent spend is growing, but do not design as if they already are.
Caps and long runs interact badly. A cap is checked per request. An agent that hits the customer's cap at step 30 of 40 gets a 402 on step 31, with half-finished work in its sandbox. Design checkpoints so a run can resume after the customer raises the cap, and decide in advance whether to absorb the last few steps of a run (Section 8) so a customer is not left with a broken branch because of a limit they set weeks ago.
How to apply this section: if your product runs agents, treat the customer's cap as a scheduling constraint. Show estimated cost before a long run starts, checkpoint during it, and make "resume after the cap is raised" a supported state rather than an error.
14. Where It Fails: Risks and Open Questions
A balanced view needs the failure modes, and linked billing has several that are structural rather than temporary.
It is a beta. It also sits behind a review gate. "Endpoints, parameters, and behavior can change during the beta. It might not be suitable for production use," says the warning at the top of Anthropic's guide, and an app Anthropic does not approve cannot be republished by its owner - Claude Platform docs. Build the integration so linked billing can be switched off per customer without touching anything else: it should be one billing source among several, never the only path a request can take.
Your costs become visible. The Linked platforms page shows each customer what your app cost them this month and what share of their total Claude spend went through linked platforms. That is good for trust and hard on any product whose AI usage is wasteful. It also invites comparison: a customer can see that your coding agent spent three times what a competitor's did on the same organization. Efficient prompting, caching and routing stop being internal cost hygiene and become visible product quality.
The lab owns the billing. Anthropic, not you, holds the billing relationship. Under developer-pays, you are the customer of Anthropic and your customers are yours. Under linked billing, Anthropic bills your customer directly, sees which platforms drive their spend, and hosts the consent screen your customer reads. Anthropic's IPO filing describes it moving up the stack with its own apps and agents, as our S-1 analysis details, and linked billing gives it per-platform usage data across every linked customer. That is not a reason to avoid it, but it is a reason to keep the parts of your product that do not depend on Claude (your data, your workflow, your integrations) as the core of what customers pay you for.
Multi-model products have to choose. Linked billing pays for Claude. A product that routes across labs either restricts linked customers to Claude, as ClickHouse does, or runs a mixed bill where some of a customer's work is paid by them and some by you. Neither is free, and the second needs exactly the per-request bookkeeping the docs ask you to keep.
Compliance-sensitive customers are excluded, quietly. Anthropic tells you not to link customers who need HIPAA, FERPA or CMEK coverage, but nothing in the API stops it. A healthcare customer's admin who clicks your button can link. Gate the button on your side for regulated tenants.
Several questions are unanswered. The documentation does not say whether usage billed to customers counts toward a platform's own commitment or volume tier, whether marketplace-billed organizations will become eligible, whether customers' negotiated discounts apply to the cap rather than only to the bill, how long review takes, or what the Linked Billing Terms contain beyond what the guide states. Plan with those as unknowns, and ask your account team before you build a pricing model that depends on any of them.
The counter-argument deserves a fair hearing. One could argue linked billing is mostly a gift to Anthropic: it helps enterprises consume commitments they already signed, shifts metering and consent onto Anthropic's surfaces, and leaves platforms with integration work and a beta dependency. For a product whose customers have no Claude organization, that is simply true. But for a product whose biggest customers already pay Anthropic directly, the alternative was holding their keys or eating their heaviest users' inference, and linked billing is a strict improvement on both.
15. A Decision Framework for Your App
The decision comes down to four questions, in this order.
1. Can your customers link? Do they already have a Claude organization billed directly by Anthropic? This is the Reach question from the scored table, and it dominates. If most of your revenue comes from engineering-led companies that already build on the Claude API, linked billing's Reach is high and it beats developer-pays on the table's own weights. If your customers are consumers, small businesses without engineering teams, or enterprises that buy Claude through a cloud marketplace, it reaches few of them today. Ask your ten largest customers before you build.
2. How much can move? How much of your cost is customer-directed inference that linked billing can carry? List your Claude calls as Section 6 suggested. Synchronous Messages and Chat Completions calls that a customer's work triggers can move; batches, billable code execution, Managed Agents and your own evaluation traffic cannot. If the movable share is large and volatile, linked billing changes your unit economics. If it is small, it is a security and procurement feature for your enterprise tier, which is still worth having.
3. Is your margin in tokens? How much of your price is a markup on tokens? If you resell inference at a margin, every request you move to linked billing gives that margin up, and your price has to move toward the value of the software. If you price inference at or below cost, linked billing removes a loss. Be honest about which one you are before you decide.
4. Can you carry the build? The billing call is trivial; the workload identity, the profile model, the refusal policy, the support copy and the review are not. A small team should expect days of work, and the work of keeping it correct (profile mapping, logging, absorb rules) does not end at launch.
The recommended design: hybrid by default
For most B2B products the answer is not linked billing instead of developer-pays, but a hybrid: keep developer-pays (or credits) as the default every customer gets, offer linked billing to customers whose organization can link, keep BYOK and the customer's cloud credentials for the enterprises linked billing cannot reach, and route each request with the policy in the diagram. The per-request billing_policy exists precisely so that one product can hold all of these at once.
A launch checklist
- Confirm with your largest customers that their Claude organizations are billed directly by Anthropic, and ask which ones buy through a cloud marketplace.
- Set up Workload Identity Federation and the operator service account, and pick a default workspace.
- Decide the profile model: one user profile per customer organization, created once, stored on the customer record.
- Write the refusal policy (absorb allowance, notifications, resume behavior) before the integration code.
- Route every Claude call through one function that derives the profile ID from the authenticated tenant.
- Keep your own ledger of which requests you sent with
bill_to: "user_profile", and reconcile againstlist_amount. - Write onboarding copy that tells customers what a typical month costs, so they set an informed cap, and that their ZDR and BAA do not extend to linked usage.
- Gate the button for regulated tenants.
- Test with a second organization of your own under the $50 testing cap, then publish early enough to clear DNS and review.
- Migrate off Sonnet 4.5 and any other retiring model before the first customer links.
Conclusion
Linked billing is Anthropic's answer to a question every AI product eventually faces: who pays for the intelligence when the customer's usage is unpredictable? Its answer is the customer's own Claude organization, at Anthropic's list price, through a consent screen Anthropic hosts and a cap the customer controls, with the app choosing request by request what to pass through. For B2B products sold to companies that already pay Anthropic directly, that is a better arrangement than both of the old ones: no customer secrets in your database, no heavy user sinking your margin, and a way for your customer to spend a commitment they already signed.
It is also narrower than the launch made it sound. It excludes organizations billed through cloud marketplaces (whose spend made up 48% of Anthropic's revenue in the first half of the year), every Claude subscription plan, the subscription plans' monthly credits, batches, billable code execution and Managed Agents, and it leaves the customer's data protections behind. And it shows each customer exactly what your product costs them, which rewards efficient products and exposes wasteful ones.
The durable strategy is the one the launch partners chose: offer it beside the other paths rather than instead of them, route each request deliberately, design for the refusal before the success, and keep the value of your product in what you build rather than in the tokens you resell. Then, when the next lab ships its own version, you will be adding one more billing source to a system built for several, not rebuilding the business around a single button.
What this article rests on
Every model figure linked above is read from its record, re-read from OpenRouter's model feed every 6 hours, so the figures on this page are current even where the prose around them is older. Prices are OpenRouter's listed price per million tokens: for a lab's closed models that is the lab's own list price, and for an open-weight model it is the price of the host OpenRouter routes to by default, which can differ from the lab's own API and from other hosts.
- Claude Haiku 5.5 (Anthropic): $0.10 in and $0.50 out per million tokens, cached input $0.01, a 1M token window, listed 7 October 2026.
- Claude Sonnet 5.5 (Anthropic): $2 in and $10 out per million tokens, cached input $0.10, a 1M token window, listed 28 September 2026.
- Claude Opus 5.5 (Anthropic): $4 in and $20 out per million tokens, cached input $0.20, a 1M token window, listed 22 September 2026.
- Claude Fable 5.2 (Anthropic): $8 in and $40 out per million tokens, cached input $0.20, a 1M token window, listed 9 November 2026.
- GPT-6.2 Astra (OpenAI): $8 in and $40 out per million tokens, cached input $0.40, a 1.05M token window, listed 17 November 2026.
- GPT-6.2 Sol (OpenAI): $2 in and $10 out per million tokens, cached input $0.10, a 1.05M token window, listed 17 November 2026.
- Gemini 4 Hydrogen (Google): $1.50 in and $7.50 out per million tokens, cached input $0.075, a 1M token window, listed 12 November 2026.
- Gemini 4 Neon (Google): $3 in and $15 out per million tokens, cached input $0.15, a 1M token window, listed 18 November 2026.
In this topic: AI costs
- ChatGPT Pro API Credits: Claim Up to $500 a Month (2026)
- AI Receptionist Cost per Call: Build vs Buy (2026)
- Claude Max API Credits: Claim Them, Ship an App (2026)
- Sign in with ChatGPT API: Users Pay Your AI Bill (2026)
- Cut AI Costs With Prompt Caching (2026)
- GPT-6 Astra Pricing: What Your App Really Pays 2026
- Set Up Metered Billing for Your AI Product 2026
- Price Your AI Product to Beat Token Costs 2026
What does AI cost to run, and how do you cut it? Every guide on it
Data behind this topic: AI model prices, context windows and release dates.