The fastest way to check OpenAI token usage across a team is the Usage API, which returns tokens, and the Costs API, which returns dollars. Both sit behind an admin key.
That covers where to look. The harder part is turning those numbers into a routine that finance and engineering both trust.
If the Claude side of your stack is next on the list, how to check Claude token usage covers it in detail. This piece stays on OpenAI.
Spot checks or scheduled pulls
A manual look is enough for one person with one project. Once several teams ship against OpenAI, use the API, because it lets you pull the same numbers on a schedule and hand finance a file.
Here's the catch. Token counts and billed dollars answer different questions, and mixing them is how a month-end review turns into an argument. Use dollar figures for anything that touches a ledger, and token counts to explain why a number moved.
How to check OpenAI token usage with the API
Pull the data on a schedule rather than checking by hand.
Both endpoints below need an admin key, which is separate from a standard project key. Create one at platform.openai.com/settings/organization/admin-keys and store it where only finance tooling and a small number of engineers can read it.
The Usage API (tokens)
The endpoint is `GET /v1/organization/usage/completions`. It requires a `start_time`, and you choose a bucket width of `1m`, `1h`, or `1d`.
You can group results by `project_id`, `user_id`, `api_key_id`, `model`, `batch`, `service_tier`, or `api_source`. Each result carries:
`input_tokens`, which includes cached and cache-write tokens
`output_tokens`
`input_cached_tokens`
`num_model_requests`
One detail trips people up. Because `input_tokens` already includes cached tokens, adding `input_cached_tokens` on top double counts them.
The Costs API (dollars)
The endpoint is `GET /v1/organization/costs`, with the same admin key. It returns daily buckets, and you can group by `project_id` or `line_item`.
What that means in practice: use the Usage API to explain why a number moved, and the Costs API to say what the number was.
How OpenAI tokens map to cost
OpenAI bills per token, with separate rates for input and output, and the rate depends on the model. That is the whole answer to what the OpenAI API costs: it is a function of model, token mix, and caching, not a flat fee.
Check the current rate for each model on OpenAI's pricing page before you build a forecast. Rates change by model and over time, so a number copied into a spreadsheet goes stale quietly.
Cached tokens are the part most forecasts miss. Tokens billed as cache reads are reported as cached tokens. On GPT-5.6 and later models, cache reads are billed at 0.1x the input rate on most models and 0.05x on some (GPT-6.1 Sol and Terra); check the pricing page for each model.
You can see this per request. The response includes `usage.input_tokens_details.cached_tokens`, and `cache_write_tokens` for tokens written to the cache.
Here is how to use that:
Take `input_cached_tokens` divided by `input_tokens` from the Usage API. That is your cache hit share.
Compare it by project, and look at any project whose hit share is low or has dropped.
Check `cached_tokens` and `cache_write_tokens` per request to see what is being reused.
If you are weighing providers, how OpenAI API cost compares with Claude goes through the rate differences side by side.
A monthly OpenAI token tracking routine for finance and eng
The routine below takes about an hour once the pulls are scripted. Run it in the first five business days of the month, after the invoice posts.
Before the first run: one-time setup
Eng: create an admin key and store it in your secrets manager.
Eng: make sure every service uses its own project, so `project_id` maps to an owner.
Finance: agree on a mapping from project to team or cost center, and keep it in one shared sheet.
Each month
Eng: pull daily Costs API data grouped by `project_id` for the prior month. Hand finance a file, not a screenshot.
Finance: reconcile the sum against the invoice. A gap means a credit, a tax line, or a missing project, and each is worth knowing about.
Eng: pull Usage API data grouped by `project_id` and `model`, with `1d` buckets. Check for any model that appeared or vanished.
Eng: calculate cache hit share per project and flag anything that dropped from last month.
Finance: compare each project to its prior month and to its budget. Write one sentence per project over its variance threshold.
Both: review the top three movers together for fifteen minutes. Decide: fix, accept, or forecast higher.
Finance: log the outcome and update next month's forecast.
Spend limits belong in this loop too. How to set LLM API spending limits covers the guardrails that stop a runaway job before month-end review catches it.
For the wider operating model across every vendor, see AI spend management for startups.