---
title: "How to audit AI spend in five steps"
description: "Audit AI spend from the providers' own usage reports. Price every token, reconcile with the invoice, and break the total down by provider, model and project."
url: https://www.cureman.de/en/articles/how-to-audit-ai-spend
language: en
updated: 2026-11-16
alternate_de: https://www.cureman.de/de/artikel/ki-kosten-pruefen.md
---

# How to audit AI spend in five steps

> An AI spend audit establishes what an organisation pays model providers, for which models and in which projects. You read each provider's usage report (tokens per day, model and project), multiply every token type by its price from a price list you keep, reconcile the result with the invoice, and break the total down. Only then do you ask what the same tokens would cost on another model, and that figure is a ceiling until requests have been measured one by one, because a usage report shows totals and not which requests were simple.

You audit AI spend by taking each model provider's usage report, multiplying every kind of token by its price, and breaking the total down by provider, model and project. The report holds the quantities and the price list holds the rates. The audit is the multiplication, the reconciliation with the invoice, and a plain list of what the report cannot tell you.

## What an AI spend audit covers

AI spend arrives on more than one line, and each line has its own source.

| Kind of spend | Unit billed | Where the quantities are |
| --- | --- | --- |
| API usage of language models | Tokens, by type and model | The provider's usage report |
| Tools and other endpoints (web search, code execution, embeddings, images, audio) | Calls, tokens or seconds | Separate usage reports, or the invoice |
| Seats for chat and coding assistants | Seats per month | The subscription and its seat list |
| Models bought through a cloud account | Tokens, on the cloud bill | The cloud provider's cost report |

This article is about the first line. Seats are a licence question; whether a seat or metered tokens is cheaper for one person is computed in [seat licence or pay per token](https://www.cureman.de/en/articles/ai-chat-seat-licence-or-pay-per-token).

## Step 1: read each provider's usage report

Providers publish usage through an administrative API that needs an admin key of the organisation. Anthropic documents its [usage and cost API](https://platform.claude.com/docs/en/manage-claude/usage-cost-api), OpenAI its [usage API](https://developers.openai.com/api/reference/resources/organization/subresources/usage/methods/get_completions).

Ask for the finest grouping the report offers: per day, per model, per project or workspace, per service tier. Each row needs four token counts: uncached input, output, tokens read from the prompt cache and tokens written to it.

Check what each figure means before adding anything up. One provider reports input tokens with the cached ones included, another reports them apart. Whoever adds both without checking counts cached tokens twice.

## Step 2: price every token

The cost of a row is a sum of four products:

```
cost = (uncached input × input price
      + output         × output price
      + cache reads    × cache-read price
      + cache writes   × cache-write price) ÷ 1,000,000
```

Keep a price list with one row per provider and model: the four prices, the address they were read from and the date. A list price is a claim until someone has checked it against the provider's current price page, so mark every row as verified or unverified. A model that is missing from the list must show as unpriced. If it silently counts as zero, it disappears from the total.

A worked example with invented figures. A month of one model: 400 million uncached input tokens, 60 million output tokens and 100 million cache reads, at invented prices of 3.00, 15.00 and 0.30 per million.

| Token type | Tokens (million) | Price per million | Cost |
| --- | --- | --- | --- |
| Uncached input | 400 | 3.00 | 1,200.00 |
| Output | 60 | 15.00 | 900.00 |
| Cache reads | 100 | 0.30 | 30.00 |
| Total | | | 2,130.00 |

How the token types differ, and why output is priced higher, is explained in [LLM token costs explained](https://www.cureman.de/en/articles/llm-token-costs-explained).

## Step 3: reconcile with the invoice

Put the computed total next to the invoice for the same period. They rarely match at once, and each reason can be named:

- **Discounts.** A negotiated rate or committed spend lowers the invoice and not the list price.
- **Service tiers.** Batch processing is billed below the standard rate, priority processing above it.
- **Charges outside the token report.** Web search, code execution, embeddings, images and audio have their own lines.
- **Cache lifetime.** A cache write with a longer lifetime can cost more than a short one.
- **Period and currency.** Reports are cut by day in UTC; invoices follow the billing period, add tax and may be in another currency.

Write the difference down with its reasons. A difference nobody can explain means the price list or the token counts are wrong, and the breakdown that follows cannot be trusted.

## Step 4: break the total down

| Cut | What it shows |
| --- | --- |
| By provider | Where the money goes, and what a commitment would be worth negotiating |
| By model | How much is spent on the largest models, where the price per token is highest |
| By project or workspace | Which product or team spends it, as far as keys are kept apart |
| By day | Jumps: a launch, a retry loop, a job that ran twice |
| By token type | Whether cost sits in long prompts or long answers, and how much input is read from cache |

The report's dimensions end at the project or workspace. Everything that runs under a default workspace or a shared key lands in one unlabelled bucket. Cost per feature, team or person needs labels set on the request itself, which is the subject of [allocating AI costs to teams](https://www.cureman.de/en/articles/allocate-ai-costs-to-teams).

## Step 5: reprice the same tokens

Take the tokens of the most expensive model and price them on a cheaper model of the same provider. With the example above and invented prices of 0.50, 2.50 and 0.05 per million for the smaller model: 400 × 0.50 + 60 × 2.50 + 100 × 0.05 = 355.00, a difference of 1,775.00 a month.

That difference is a ceiling and not a saving. It is what would be saved if every request moved, and nobody knows yet which requests could. The same holds for caching: little input read from cache combined with large prompts per request suggests that repeated prompts are paid at the full input price, but the report does not say which prompts repeat. See [prompt caching and context](https://www.cureman.de/en/articles/prompt-caching-and-context).

## What the usage report cannot tell you

A usage report holds totals, not requests. It cannot say which requests were simple, which prompt prefixes are sent again and again, which feature or person caused the cost, or how many requests were exact repeats of an earlier one. Those questions need metering per request, which is what [an LLM gateway](https://www.cureman.de/en/articles/what-is-an-llm-gateway) does when it observes traffic without changing it.

## What goes wrong

- **Reading the dashboard and skipping the invoice.** The dashboard shows usage; only the invoice shows what was charged.
- **Counting the same traffic twice.** If provider reports and your own request logs both feed the total, one of them has to give way.
- **Reporting the ceiling as a saving.** A repricing of all tokens does not survive the first request that needs the larger model.
- **Stale prices.** Providers change prices and retire models. A price list without dates cannot be checked.

## How Cureman does it

Cureman reads the usage reports of the connected providers through read-only connectors with an admin key: tokens per day, model, project or workspace and service tier. It prices every token type against a model price list. A price that nobody has verified is labelled as unverified wherever it appears, and the page says which providers' cost is computed from token counts and list prices and so reflects no negotiated discount. Spend is shown by provider, model, project and day. For each model, the same tokens are repriced on cheaper models of the same provider, with no assumption about quality; that figure is shown as a ceiling and is not counted as an identified saving. Requests metered by the gateway enter the total only for providers without a connected report, so no traffic is counted twice. The module is described on the page about the [AI spend audit](https://www.cureman.de/en/modules/ai-spend-audit).

## Questions and answers

### What is an AI spend audit?

It is a check of what an organisation pays model providers, computed from the providers' own usage reports. Every token type is multiplied by its price, the total is reconciled with the invoice and then broken down by provider, model and project. The result is a breakdown anyone can recompute, and a list of questions the report cannot answer.

### Where does the token usage of an organisation come from?

From each provider's usage report, which is read through an administrative API with an admin key of the organisation. It lists tokens per day, model and project or workspace, split into uncached input, output, cache reads and cache writes. A normal API key cannot read it.

### Why does the computed cost differ from the provider's invoice?

The usual reasons are a negotiated discount, service tiers such as batch or priority processing, charges outside the token report such as web search or embeddings, and a billing period that is cut in another time zone. Each of them can be named and quantified. A difference nobody can explain means the price list or the token counts are wrong.

### Can a usage report show which requests could have used a cheaper model?

No. A usage report holds totals per day, model and project, and no single request. It can show what the same tokens would cost on a cheaper model, which is a ceiling. Which requests were simple enough to move is only visible when requests are metered and classified one by one, for example by a gateway that observes without changing anything.

## The module that does this

[AI spend audit: model costs by provider, model and project](https://www.cureman.de/en/modules/ai-spend-audit): The AI spend audit reads usage reports from model providers, prices every token against a model price list and shows spend by provider, model and project.

## Read next

- [LLM token costs explained: input, output and cached tokens](https://www.cureman.de/en/articles/llm-token-costs-explained): What input, output and cached tokens are, why output tokens cost more than input tokens, and how to compute the cost of a single LLM request step by step.
- [What is an LLM gateway, and when do you need one?](https://www.cureman.de/en/articles/what-is-an-llm-gateway): An LLM gateway is a proxy between your applications and the model providers. What it meters per request, how upstreams and keys work, and when it is worth having.
- [How to allocate AI costs to teams, projects and people](https://www.cureman.de/en/articles/allocate-ai-costs-to-teams): A method to attribute LLM spend to teams, features and people with keys, tags and user identifiers, price every request and reconcile with the provider.
