# Anthropic linked billing beta: can customers pay for Claude?

URL: https://infro.io/blog/anthropic-linked-billing-beta-can-customers-pay-for-claude
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-11-19
Last modified: 2026-11-19
Last reviewed: 2026-11-19 (next review due 2026-12-19)
Topic: Cost and FinOps
Format: Analysis

> Yes, in beta and for a narrow set of customers: those whose Claude organization pays Anthropic directly can be billed per request, while the requests still run in your organization under your limits and retention terms [^release-notes][^linked-billing]. The invoice moves to the customer; the account, rate limits, key and most of the attribution and budget work stay with you.

Key takeaways:
- Linked billing moves the invoice to the customer's Claude organization, but requests still run in your organization, so your rate limits, model access, service tier, data retention and encryption keys apply.
- Only customers whose organization pays Anthropic directly are eligible; AWS, Google Cloud or Azure billing and subscription-only organizations get a 403 user_profile_not_billable.
- It is a beta that Anthropic says might not be suitable for production use, so keep a fallback path where you pay and bill the customer yourself.
- The customer's Console cap and a 402 refusal do not tell your app why a request failed, so you still need your own per-customer cap, a reset time to show, and a usage ledger.
- A gateway's estimates measure what passed through it; whether linked-billing fields pass through your gateway is something to test, not assume.

## What Anthropic shipped on November 17

Anthropic announced Linked billing in beta on November 17, behind the `user-profiles-billing-2026-10-01` beta header. A customer links their own Claude organization to your app, and you then set `billing_policy` on each `/v1/messages` or `/v1/chat/completions` request to choose who pays. In the Claude Console the customer can set a spend cap for your app or unlink it.[1]

Two cautions before the mechanics. Anthropic labels Claude Platform OAuth a beta service whose endpoints, parameters and behavior can change, and says it might not be suitable for production use.[2] And the arrangement is narrower than "customers pay Anthropic": it covers customers whose Claude organization pays Anthropic directly, and you may bill a customer only for requests they direct you to make, never for your own usage.[3]

The rest of this piece is for product, platform and finance leads deciding whether to design around it. The short version: it changes who gets the invoice. It does not move the account, the limits or most of the measurement work.

## Who owns what: linked billing against the alternatives

Three setups get confused. In the first you pay Anthropic and charge your customers yourself. In the second, linked billing, the customer's Claude organization pays per request. In the third a gateway sits on your own provider accounts (BYOK in the gateway sense: you hold the contract and the keys, and the gateway does not sell you inference).[4] A fourth variant, the end customer pasting their own key into your app, is a different thing again and is only in the table for contrast.

|  | You pay, you bill customers | Linked billing | End customer pastes own key |
| --- | --- | --- | --- |
| Account the request runs in | Yours | Yours | The customer's |
| Credential your back end uses | Your key | Your service account, or a per-connection OAuth token | The customer's key |
| Rate limits that apply | Yours | Yours | The customer's |
| Who is invoiced by Anthropic | You | The customer, for requests marked for them | The customer |
| Data retention and encryption terms | Yours | Yours; the customer's ZDR, BAA and CMEK do not apply | The customer's |

Table: ownership by setup. The linked billing column follows Anthropic's Linked billing guide; the other columns are general to those setups.

The last row is the one that surprises people. Anthropic states that requests run in your organization, so your rate limits, model access, service tier, data retention and encryption keys apply, and the customer's own arrangements, including zero data retention, a business associate agreement and customer-managed keys, do not. Anthropic's advice is not to link customers who need HIPAA, FERPA or CMEK coverage for this usage.[2]

## Who can be billed, and which calls qualify

Eligibility is the first filter, and it is a finance question as much as an engineering one. A customer qualifies only if their Claude organization pays Anthropic directly. Organizations billed through AWS, Google Cloud or Azure cannot be billed this way, and neither can organizations that only have a Claude subscription plan; requests for them are refused with `403 user_profile_not_billable`.[2] To link, the person approving must hold the Admin or Billing role in their Claude organization.[3]

Funding has limits too. Balance bought in the Console can pay for these requests, and an invoiced organization is invoiced for them. Some promotional allowances, such as the monthly API allowances that come with Claude Max, Ultra and Team plans, and allowances from partner, VC and startup programs, cannot pay.[2]

Endpoint coverage is also partial:

- `/v1/messages` and `/v1/chat/completions` support `billing_policy`. `/v1/messages/count_tokens` accepts the field and ignores it.
- A request that bills the customer cannot use billable code execution features; the API returns a 400, so send those with `bill_to: "self"` or no policy.
- Message Batches does not support billing the customer. A batch request that sets `bill_to: "user_profile"` is refused, and neither side is billed for it.[2]

If your product leans on batch or code execution for customer-directed work, those paths stay on your invoice.

## The identity plumbing you take on

The customer-facing step is one button. The back-end step is not small. You register an OAuth app in the Console, set up client authentication with a token from your own identity provider (Anthropic does not issue client secrets), and create a service account plus a federation rule that serves as the app's operator identity.[2] Your back end authenticates to the authorization endpoints with `private_key_jwt`, and a client assertion may live no more than one hour.[5]

By default, any authenticated request as the operator service account can bill every linked customer, by setting the user profile header and `bill_to`. Anthropic describes a tighter option: tokens issued per connection, where a request made with a connection's token is billed to that connection's customer and to no other.[2][5] For a finance reviewer, that is the difference between "our code is trusted to pick the right customer" and "the credential cannot pick the wrong one". Decide which you are running before launch.

The customer record mapping is one-to-one. Each customer needs a user profile in your organization; one Claude organization links to one profile and one profile to one Claude organization. Several teams that share a Claude organization share one profile. A company gets one profile, not one per person.[2][6] Settle that before you link the first customer.

## What still has to live on your side

Linked billing answers "who is invoiced". It leaves the following with you.

**Your own capacity.** All linked customers' requests run under your organization's rate limits, so one heavy customer can consume capacity others need. A per-customer concurrency or rate rule is yours to build.

**A cap you can explain.** The customer can set a spend cap in the Console. When nothing on their account can pay, the API can refuse with a 402, and the response does not say whether a lack of funds or a spend limit caused it.[2] Your app cannot tell the user which one to fix, and the response does not give you a reset time. If you want a message such as "your monthly AI limit resets on the 1st", you need your own per-customer counter. INFRO's end-customer caps work this way on traffic through the gateway: a cap per end customer, with overrides, and a refused request returns a 402 with the reset time for your app to show.[7]

**A separate ledger for own usage versus customer usage.** Requests with no profile count as your own usage, and Anthropic advises keeping end-customer traffic and internal traffic in separate organizations.[6] Evals, background jobs and support tooling should be `bill_to: "self"` and tagged as such, so you can prove none of it reached a customer's invoice.

**Per-customer usage for reconciliation.** The customer will see an Anthropic invoice and may compare it with what your app displays. Keep your own record per request: customer id, model, tokens, and whether it was marked for the customer or for you. INFRO records requests, tokens and estimated provider cost for each end customer id you attach, by day or month, project and model, as a CSV or JSON export, and attributes spend by feature and workflow metadata.[8][9] These are estimates of provider cost, not Anthropic's invoice.

**A fallback.** Unlinking, a funding failure or an ineligible customer type all land on your app. Decide per plan whether a refused request falls back to a plan you pay for, or stops.

## A request sketch

> **Example: Illustrative request, not a verified schema**
> The field names below are a sketch for planning. Anthropic's release notes name `billing_policy` and the values `bill_to: "user_profile"` and `bill_to: "self"`, and its user profiles page names the `anthropic-user-profile-id` header; check Anthropic's Linked billing page for the exact shape before you write code.[1][6]
> 
> ```json
> {
>   "model": "claude-sonnet-5-5",
>   "max_tokens": 1024,
>   "messages": [{"role": "user", "content": "Summarise this ticket"}],
>   "billing_policy": {"bill_to": "user_profile"}
> }
> ```
> 
> Sent with the beta header `user-profiles-billing-2026-10-01` and the customer's profile id. Your own jobs would send `"bill_to": "self"` or omit the policy.

The point of the sketch is where the decision sits: per request, in your code. That makes the marking logic a control. Put it in one function, log its output, and review the log the way you would review a pricing rule.

## Where a gateway fits, and what to test first

A BYOK gateway sits on your own provider accounts. It measures and limits the traffic that passes through it, and your provider invoices you directly at your own rates.[4] That is the opposite end of the ownership spectrum from linked billing, where Anthropic invoices the customer. They can coexist, but nothing in the pages read here confirms that a particular gateway forwards `billing_policy` or the profile header, or whose rates a customer-billed request carries. Treat both as open questions and test before you route linked-billing traffic through anything.

If the customer-billed requests do bypass your gateway, the per-customer cap and usage export will not see them, and you will need the other ledger described above. If your gateway does carry them, check whether its estimates, which use your contract's rates, are the right figure to show a customer.

A decision rule for finance and product:

1. Use linked billing for customers who are on direct Anthropic billing, do not need ZDR, a BAA or CMEK on this usage, and whose work uses `/v1/messages` or chat completions.
2. Keep paying and billing yourself for batch, code execution, cloud-billed and subscription-only customers.
3. Keep a beta fallback: Anthropic says behavior can change, so avoid making it the only way a customer can use the feature.
4. Build the per-customer cap and ledger regardless of which route a customer takes.

## Questions

### Does linked billing replace the end customer pasting their own API key into my app?

They solve similar problems differently. With linked billing the customer approves your app through OAuth and never hands you a key; you call Claude as your own organization and mark which requests the customer pays for [3]. A pasted key keeps the customer's own account, limits and data terms on the request, which linked billing does not.

### What happens if the customer unlinks my app?

The customer can unlink at any time, and a request you mark for the customer that cannot be billed to them is refused rather than billed to you [2]. Your app should treat that as a state to handle, with a message and, if you choose, a fallback to a plan you pay for.

## Sources

1. Claude Platform release notes — Anthropic. https://docs.anthropic.com/en/release-notes/api (accessed 2026-11-19)
2. Linked billing — Anthropic. https://platform.claude.com/docs/en/manage-claude/oauth-apps/organization-billing-connections (accessed 2026-11-19)
3. Claude Platform OAuth — Anthropic. https://platform.claude.com/docs/en/manage-claude/oauth-apps/overview (accessed 2026-11-19)
4. INFRO documentation — INFRO. https://infro.io/docs (accessed 2026-11-19)
5. OAuth reference — Anthropic. https://platform.claude.com/docs/en/manage-claude/oauth-apps/oauth-reference (accessed 2026-11-19)
6. User profiles for end-customer attribution — Anthropic. https://platform.claude.com/docs/en/manage-claude/user-profiles (accessed 2026-11-19)
7. End-customer caps — INFRO. https://infro.io/docs/org/end-customer-caps (accessed 2026-11-19)
8. Usage per end customer — INFRO. https://infro.io/docs/org/end-customer-usage (accessed 2026-11-19)
9. Cost attribution — INFRO. https://infro.io/docs/features/attribution (accessed 2026-11-19)
