One dashboard for every AI bill you run
A provider's usage page shows one service's past in its own units. A cost dashboard prices every provider into money, adds it up, and projects where the month is heading. Here's what one should show, and the two ways it gets its numbers.
Every AI provider hands you a usage page, and it's easy to mistake that for a cost dashboard. A usage page is a single instrument reading one quantity: one provider, one unit, and only ever the past. A dashboard is the whole panel — every provider you run, each priced into money, summed into one figure that points at where the month is heading.
This guide covers what an AI API cost dashboard is, the panels a good one shows, and the choice that shapes everything else: the two ways a dashboard gets its numbers, either by instrumenting your code or by reading the bill each provider already keeps.
What is an AI API cost dashboard?
An AI API cost dashboard is a single view that turns every provider’s raw usage into money and shows it as one number you can budget against. It sits on top of three things worth keeping separate: Usage is the raw meter each provider keeps: tokens, GPU-seconds, characters, requests. A running total prices that usage into money and adds it up to the moment — what the month has cost so far. A forecast takes the rate underneath that total and extends it across a full month at the current pace.
A provider’s usage page gives you the first of those, for one provider, in that provider’s own unit. A cost dashboard does the rest: it prices every provider’s usage into money so the units stop mattering, sums the lot into one total, and projects it forward. A meter records what one service did. A budget is what all of AI is costing you, and where it’s headed.
What should an AI API cost dashboard show?
Four panels do most of the work:
- One cross-provider month-to-date total. A single money figure for everything you run, instead of a number per console that you add up yourself.
- A forecast. What next month costs at your current pace. This is the panel that looks ahead.
- A per-provider and per-model breakdown. Which provider, and which model inside it, is moving the total, so a jump has an obvious source.
- A spend trend. A line over recent days that makes a developing climb visible while there’s still time to react.
Notice what isn’t on that list: a wall of per-request traces. That granularity belongs to a different kind of tool (more on that next). For a solo dev it’s mostly a distraction — you’ll check the monthly number ten times for every single call you stop to trace. A good cost dashboard is glanceable. You open it, read the forming month, close it. CostCompass works that way: it stays quiet until you look, then shows you the number on demand.
Where does a cost dashboard get its numbers?
This is the choice that defines the tool, and there are two answers to it.
Instrument your code. Observability SDKs and AI gateways — LiteLLM, Langfuse, Helicone, Portkey, Datadog’s LLM Observability — count tokens as they flow, some by wrapping your provider SDK, others by routing every request through a proxy between your app and the provider. Done well, you get per-request cost attribution, plus tracing and prompt-level debugging. The price is that the tool now lives in your code or your request path: an SDK to install, or a gateway sitting in your latency budget. And because it only sees what flows through it, it’s built around model tokens. The GPU box, the hosting bill, a voice service — those usually fall outside what it tracks. Most of the dashboards that rank for this search work this way. (For the named tools in each camp — proxies, SDKs, and billing-API readers — sorted by how AI cost tools collect their numbers, see the side-by-side.)
Read the bill. The other approach reads each provider’s own usage or billing API directly, when you ask it to, and prices the result into money. Because it reads the records the provider already keeps instead of intercepting your traffic, there’s nothing in your request path: no SDK to install, no proxy in front of your app. It spans anything with a readable usage API, so compute and flat subscriptions sit on the same panel as model tokens. Each provider documents the feed it reads from — Anthropic’s Admin API, OpenAI’s API, and Google Cloud billing. The trade-off is granularity: it reports at the provider’s own resolution, not per individual request.
| Approach | In your request path? | One cross-provider total | Covers compute & subscriptions | Granularity |
|---|---|---|---|---|
| Instrumented (SDK / gateway) | Yes — code or proxy | Only what flows through | Rarely — token-shaped | Per request |
| Read the bill (usage APIs) | No | Yes | Yes | Provider’s own |
The two answer different questions. To debug a single expensive call, instrument it. To know what AI is costing you this month across everything you run, reading the bill answers that with nothing installed in your application. For most solo developers the second question is the one that comes up week after week, and the first only when a bill jumps. (For the wider set of methods, including a spreadsheet, see how to track AI costs across providers.)
Build your own, or connect one?
Once you’ve decided to read the bill, there’s a second fork: write the dashboard yourself, or connect one. Rolling your own starts simple — a script that hits one provider’s usage API. It gets harder fast. Every provider meters differently and prices differently, so you end up maintaining a pricing table and a unit conversion for each one, re-checking them every time a provider changes its API or its rates. And you still have to sum across providers, store history for a trend, and build the forecast on top. It’s a real project that’s never finished, because the providers keep moving.
Connecting a ready dashboard trades that maintenance for a one-time setup. The pricing math, the unit conversions, the roll-up, and the forecast are already built and kept current, and a new provider folds in without you writing another reader. Both end at the same place: one total and a forecast. What differs is upkeep — how much of your time the number costs to keep, and how current it stays when you’re busy shipping.
A cost dashboard for every provider you run
CostCompass is a read-the-bill dashboard. You connect each provider once; after that, a click on Refresh reads that provider’s usage and prices it into money, so a dozen different meters land in one comparable figure.
You pull the data here. Refresh fetches the latest usage from every connected provider on demand. There’s no constant polling, because there’s no point calling your providers when you aren’t looking. It stays quiet until you want the number. Then one click brings every provider’s latest usage in at once, already priced and broken down so the source of any change is obvious.
Two things make it practical for a solo developer. First, nothing touches your code: CostCompass reads each provider’s usage API directly, so there’s no SDK wrapping your calls and no gateway in your request path, and your application runs exactly as it did before. Second, your keys are encrypted in your browser before they’re ever stored, sealed with your vault password and saved only as ciphertext the server can’t decrypt. It also doesn’t stop at model APIs. The same panel rolls Claude and OpenAI up next to the GPU box, the hosting bill, and a voice service, across every provider it supports. That compute spend is what most token-only dashboards leave out.
For how that forward number is built from the usage, see forecasting your AI spend. For how individual providers bill, the per-provider guides go deeper — Claude, OpenAI, and Gemini, with the full set on the providers page and a wider overview of tracking AI costs across providers.
Getting a dashboard in front of you takes three steps:
- Connect a provider — paste the usage or admin key it gives you. It’s encrypted in your browser before it’s stored, so the server only ever holds ciphertext.
- Click Refresh to pull recent usage; the month-to-date total, forecast, and per-provider breakdown appear together.
- Add the rest. Each provider folds into the same dashboard, so one panel covers everything, and a click on Refresh rebuilds it from the latest usage whenever you want it.
Frequently asked questions
- What is an AI API cost dashboard?
- A single view that pulls every AI provider you use into one money figure — what you've spent this month, what you're on track to spend, and which provider and model account for it. A provider's own usage page covers one service in its own unit. A cost dashboard prices every provider's usage into money, adds it into one total, and projects it forward. It replaces a row of consoles you read and add up by hand with one panel that answers "what is AI costing me" at a glance.
- Do I need an SDK or a gateway in my code to get one?
- No. That's only one of the two ways to build a dashboard. Instrumented tools count tokens by wrapping your provider SDK or routing every request through a proxy, which means code in your request path. The other approach reads each provider's own usage or billing API after the fact, so nothing sits in your application and nothing is added to your latency. CostCompass takes that second road — connect a provider once and it reads the records the provider already keeps.
- Can one dashboard cover providers that bill in different units?
- Yes — that's the main thing a cost dashboard does that a usage page can't. Each provider meters in its own unit — tokens for a model API, GPU-hours for a rented box, characters for a voice service, requests and bandwidth for hosting. Once each meter is priced into money at that provider's rates, the figures become directly comparable and add into one total. The unit stops mattering the moment everything is money.
- Does a cost dashboard show only what I've spent, or where I'm headed?
- A good one shows both. The month-to-date total is the rear-view figure — what the month has cost so far. The forecast takes your recent daily pace, extends it across next month, and folds in next month's fixed subscriptions, so you read where the trend lands before the invoice does. In CostCompass both recompute from the latest usage each time you click Refresh. It's on demand rather than a background poll, so a developing climb shows up the next time you look, with days left to act on it.
- Where do my provider keys live?
- In a vault encrypted in your browser. Each key you connect is sealed with your vault password and stored only as ciphertext CostCompass can't decrypt, so the App Server only ever holds that ciphertext. When usage is fetched the key is decrypted in your browser and forwarded to the provider through a broker built not to log it, so the plaintext stays out of the database and the logs.
- Why use CostCompass instead of building your own dashboard?
- Building it yourself means writing a reader for each provider's usage API, keeping each one's pricing math current, converting every meter to money, then summing it and projecting a forecast — and maintaining all of that every time a provider changes its API or its rates. CostCompass is that dashboard already built. Connect each provider once and one click pulls a single month-to-date total, a forecast of next month at your current pace, and a per-provider, per-model breakdown across model APIs and compute alike, with nothing in your request path. You read one number instead of building and maintaining the thing that produces it, and the day you add a provider it's already folded in.
About the author
Joubert Berger builds CostCompass, a spend-intelligence dashboard that pulls usage from AI and compute providers into one month-to-date total, a forecast, and a per-provider breakdown. This guide reflects how CostCompass reads each provider's own usage API — see the security model for how your keys are handled.
Put every provider on one dashboard
Connect each provider once and pull a single month-to-date total, a forecast, and a per-provider breakdown on demand. Nothing wired into your request path.