/en/articles/claude-now-lets-your-customers-pay-for-their-own-tokens-how-linked-billing-works

AI

Claude now lets your customers pay for their own tokens: how Linked billing works

On November 17, 2026, Anthropic launched Linked billing in beta on Claude Platform: a way for your app's customers to pay for the API calls your product makes using their own Claude account. The customer links their organization once, and from then on, on every request, you decide who pays: them or you. For anyone selling a SaaS, a bot, or an internal tool built on Claude, this hits the most awkward problem in the business: eating the cost of other people's tokens and then trying to recoup it through margins and pricing plans.

What Anthropic announced

According to the Claude Platform release notes, the feature is enabled with the beta header user-profiles-billing-2026-10-01. Once a customer links their organization, the app adds a billing_policy field to each call to /v1/messages or /v1/chat/completions to indicate who pays. From the Claude Console, the customer can set a spending cap for your app or unlink it whenever they want.

The Linked billing documentation explains the rest. Your app shows a "Link your Claude organization" button; the customer goes to Claude, picks their organization, and approves. The API calls that link a connection. There's one guarantee worth underlining: if a call marked for the customer can't be billed to them, the API rejects it instead of silently charging you.

How it works under the hood

The setup has two parts. The first is done once and requires the Admin role in your organization:

  • Create an OAuth app in the Console with the "Bill and link to organizations" permission and a redirect URI. Anthropic doesn't issue client secrets: your back end authenticates with tokens from your own identity provider.
  • Create a service account with Workload Identity Federation and assign it as the app's "operator service account." Only that account can send calls that are billed to linked customers, and each service account operates a single app.

The second part is repeated per customer: you create a user profile in your organization to represent them, send a pushed authorization request with PKCE to auth.claude.com, redirect the customer to the approval page, and when they come back with the code, you exchange it for a connection_id that you store in their record. The relationship is one-to-one: a Claude organization can only be linked to one of your profiles, and a profile to only one organization.

Diagrama del flujo de Linked billing: la app crea un user profile, el cliente aprueba en auth.claude.com y en cada request billing_policy decide si paga el cliente o el desarrollador

On each call you send the anthropic-user-profile-id header with the customer's profile. If you want them to pay, you add "billing_policy": {"type": "billing_policy", "bill_to": "user_profile"} and the beta header. If you pay, you omit billing_policy or use bill_to: "self".

The documentation also describes a stricter variant: per-connection OAuth tokens, which can only bill that customer and expire in at most one hour (with refresh tokens of up to a year if you request offline_access). It's the option for single-customer deployments or sandboxes controlled by the customer themselves.

Who can pay this way (and who can't)

Here's the fine print. According to the documentation:

  • It only applies to Claude Platform organizations that pay Anthropic directly, with prepaid credits or monthly invoicing (invoiced billing). Those that pay through AWS, Google Cloud, or Azure Marketplace, or that only have a Claude subscription, are left out: their calls return 403 user_profile_not_billable.
  • Not all credit works. The monthly API credits that come with the Max, Ultra, and Team plans, and those from partner, VC, and startup programs, can't pay for these calls.
  • Calls run in your organization: your limits, your model access, your data retention, and your encryption keys apply. The customer's agreements, such as zero data retention, a BAA, or customer-managed keys (CMEK), don't count. Anthropic explicitly asks you not to link customers who need HIPAA, FERPA, or CMEK coverage for that use.
  • Paid code execution features return a 400 if you try to bill them to the customer, and Message Batches doesn't support this type of billing yet.

Spending caps and errors to handle

When linking, the customer can set a monthly dollar cap for your app, separate from the monthly limit on their whole organization. You can't read that cap or see how much has been spent. While your app is in testing or under review, the cap is mandatory and can't exceed 50 dollars. To publish it, you have to verify your domain with a TXT record and pass an Anthropic review, unless your organization has invoiced billing (you're billed on credit): in that case it goes live as soon as you confirm.

The errors your code needs to expect:

Code What it means Retry?
403 user_profile_not_billable That customer can't be billed; the API doesn't say why Only within the first 10 seconds after linking
402 linked_organization_spend_limit_reached The customer hit their cap or has no valid credit No
402 linked_organization_billing_unavailable The customer's organization can't be billed (for example, it's suspended) No
503 overloaded_error The charge couldn't be confirmed at that moment Yes, with backoff

In all rejection cases, the documentation suggests the same plan B: resend with bill_to: "self" and absorb the cost yourself. Another operational detail: if the customer unlinks your app, Anthropic doesn't notify you by webhook or email. You find out because the 403s start, or by checking the profile's status with the beta header user-profiles-search-2026-08-30.

My take

What this means in practice is that the "bring your own key" model stops being a hack. Today, many apps ask the customer to paste their API key into a form, which is awkward and risky for both sides. Linked billing replaces that with a proper OAuth flow, customer-controlled spending caps, and a button to cut off access. For a developer who sells bots, agents, or automations built on Claude, it opens the door to charging only for their software and letting whoever generates the AI usage pay for it.

But the fine print weighs a lot. The customer has to be, in turn, a direct Claude Platform customer with paid credit, which leaves out most small businesses that only use Claude through a subscription or a cloud marketplace. Also, responsibility doesn't shift: the documentation says you provide the support, that the API can't verify whether a call was really requested by the customer, and that data travels under your terms, not theirs. The setup (Workload Identity Federation, PAR, PKCE, app review) isn't an afternoon's work either.

I haven't tested it; all of this comes from the official Claude Platform documentation. If you build on Claude for enterprise customers who already have an account with Anthropic, it's worth setting it up in testing now, with the 50-dollar cap, and designing the fallback to bill_to: "self" from the start for when charging the customer fails.

Sources