AI API Cost Allocation: How to Split One LLM Bill Across Projects

Tracking tells you who used what. Allocation decides who pays.

Tagging requests by project is the first half of the job, and our AI API cost tracking guide covers it. This article is the second half. At the end of the month there is one invoice. Part of it maps neatly to tagged requests. The rest does not: a search index three products share, test runs, scripts nobody tagged, and a gap between what your logs add up to and what the provider billed.

Allocation is the set of rules that turns that invoice into one number per project, and those numbers must add up to the invoice. If they don't, someone will ask where the rest went, and the report loses trust.

invoice = direct costs (tagged requests)
        + shared pools (indexes, evals, platform features)
        + untagged requests
        + gap (invoice minus what your logs add up to)

project share = its direct cost + its part of each pool

What to log on every request

Use separate OpenAI projects, Anthropic workspaces or Google Cloud projects per product where the provider allows it. That gives you a coarse split from the provider's own usage reports. It cannot see features or customers inside a product, so log these fields in your own code as well:

• project or cost center, set where the API client is created, not where the prompt is written
• feature or workflow, such as support-reply or weekly-summary
• environment: production, staging or development
• a pseudonymous customer or tenant ID if you want per-customer cost
• model, plus input, cached input and output token counts from the API response
• request ID and whether the call was a retry

Read token counts from the usage field the API returns, not from an estimate of the prompt. Reasoning tokens, tool definitions and retries are in the real numbers and not in your guess. Then price each record from one current price table, so every project is priced the same way.

A worked split: one $10,000 month, three projects

Here is a made-up month for a company with three AI features on one provider account. The numbers are round so the arithmetic is easy to follow; your pools will have different sizes.

Direct costs are $8,000, so the three projects' direct shares are 50%, 30% and 20%. The other $2,000 needs rules. These are the ones we would write down for this month:

• Shared index ($300): split by retrieval queries. Support ran two thirds of them and the internal assistant one third, so $200 and $100. Sales does not use the index and pays nothing.
• Evals ($600): split by direct share, so $300, $180 and $120. If each test suite carries a project tag, charge it directly instead.
• Gap ($200): split by direct share, so $100, $60 and $40.
• Untagged ($900): keep it as its own line, or split it by direct share if every dollar must be charged back.

Both versions add up to $10,000. The showback version leaves $900 visible as unallocated. The chargeback version makes Support pay $450 for requests nobody can prove were Support's. That is fair only if untagged traffic really follows the same pattern as tagged traffic, and you rarely know that.

Split shared costs by dollars, not tokens

Token counts look like the neutral way to split a shared cost. They are not, once projects use different models. Say Support runs on Claude Sonnet 5.5 and sends 300 million input and 30 million output tokens a month, while the internal assistant runs on Claude Haiku 5.5 and sends three times that: 900 million input and 90 million output.

By tokens, the internal assistant would carry 75% of every shared pool. By dollars it carries only a small part, because its model is far cheaper. A team that moves to a cheaper model to save money should not end up paying more of the shared costs for it. Dollar share follows the bill, so use it unless a pool has a clearer driver, like retrieval queries for a search index.

Allocation keys that work, from most to least direct: the pool's own usage measure (queries against an index, test cases per suite), then each project's direct dollar cost, then active users or requests. An even split is the last resort; it is simple and almost always wrong for someone.

Untagged traffic: find it before you spread it

Untagged spend in our example is 9% of the bill. Spreading it hides the problem that created it. It usually comes from a few places: scripts and notebooks using a shared key, a background job written before tagging existed, a new service that forgot the tag, or a developer testing in production.

• Group untagged requests by API key, model and hour of day; scripts and batch jobs show up as clear clusters.
• Give each person and each job its own key, so an untagged request at least has an owner.
• Pick a limit for untagged spend, such as 5% of the bill, and review it every month. We use 5% as a working target, not an industry figure.
• Reject or flag requests without a project tag in your API wrapper once coverage is good.

Close the gap to the invoice every month

Your priced logs will not equal the invoice exactly. Common reasons: cache writes or long-context rates your price table does not apply, tool fees such as web search, batch or priority pricing, requests that failed after tokens were billed, a price change mid-month, and taxes or credits on the invoice. In the example the gap is $200, or 2%.

Spread a small gap by direct share, as above. When it is large, find the cause first; it often means one project uses a feature your price table does not model, and that project should get the cost. Keep the gap as its own line in the report, so a growing gap is visible instead of quietly raising everyone's numbers.

From project cost to cost per customer

The same method works one level down. With a customer or tenant ID on each request, a project's direct cost splits by customer, and its share of the pools can follow the same rule. That is the number to compare with what each customer pays you. The AI SaaS margin calculator takes cost per customer and plan price and shows the gross margin. To limit what one customer or team can spend, see AI API budget limits.

If a project's direct cost is the problem rather than the split, price the same workload on other models with the AI API cost calculator before you change anything.

FAQ