If you use more than one model or coding agent, the only sane way to track AI spend is to normalize everything to cost per 1M tokens and then roll it up by tool, model, and task. Otherwise you end up with a pile of vendor dashboards that don’t agree with each other.
The practical move is simple: read the logs your agents already keep locally, compute cost from current per-1M-token prices, and review the result as a 30-day table before you ship anything expensive.
Why vendor dashboards are not enough
Every serious AI workflow today is multi-tool. You might use Claude Code for implementation, GPT-4o for a second opinion, Gemini for a fast pass, and a wrapper in Python or Node for a product feature. Each vendor shows you its own slice of the picture, but none of them give you a clean cross-provider answer to the question that matters: what did this actually cost me?
That gap matters because the same project can look cheap in one dashboard and expensive in another, depending on whether you are counting input tokens, output tokens, cached tokens, reasoning tokens, or just the subset of usage that happened on one platform. If you want a real budget, you need one normalized view across providers and tools. That is exactly why a public benchmark like the AI Cost Index is useful, and why live model pricing matters when you are comparing a fast model against a heavier one.
Here is the core rule: prices are always quoted per 1M tokens. If a model charges $2.50 per 1M input tokens and $10 per 1M output tokens, you do not think in per-token terms. You think in token buckets, then multiply by the right rate. That keeps the math honest and makes comparisons possible across vendors.
The math: what one request really costs
Let’s do a worked example using GPT-4o, which is priced at $2.50 input and $10 output per 1M tokens. Suppose a coding assistant sends 12,000 input tokens and gets back 3,000 output tokens.
The arithmetic is:
Input cost = (12,000 / 1,000,000) * 2.50 = $0.03
Output cost = (3,000 / 1,000,000) * 10.00 = $0.03
Total cost = $0.06That request is not “six cents because the model is pricey.” It is six cents because the output is expensive relative to the input, and the output token count is still meaningful. If you ran the same token counts through gpt-4o-mini, priced at $0.15 input and $0.60 output per 1M tokens, the same call would cost:
Input cost = (12,000 / 1,000,000) * 0.15 = $0.0018
Output cost = (3,000 / 1,000,000) * 0.60 = $0.0018
Total cost = $0.0036That is a 16.7x difference on the same token shape, which is why model choice matters more than most teams admit. If you want to compare these kinds of tradeoffs more systematically, the live model list is where the per-1M-token numbers stay current.
A small comparison that actually helps
For day-to-day budgeting, the most useful comparison is not “best model” in the abstract. It is which model gives you the right quality at the right token shape. Here’s a compact view of a few models developers actually use:
| Model | Input price | Output price | What it suggests |
|---|---|---|---|
| gpt-4o-mini | $0.15 / 1M | $0.60 / 1M | Good for cheap, high-volume tasks |
| deepseek-chat | $0.28 / 1M | $0.42 / 1M | Very low-cost option for many workloads |
| gemini-2.5-flash | $0.30 / 1M | $2.50 / 1M | Cheap input, pricier output |
| claude-sonnet-4-5 | $3 / 1M | $15 / 1M | Mid-to-high cost, better suited to harder tasks |
| claude-opus-4-1 | $15 / 1M | $75 / 1M | Use when quality justifies the spend |
Notice what this table does not do. It does not pretend one price wins everywhere. A model with a low input rate can still get expensive if it produces a lot of output. A model with a higher input rate can be fine if it finishes the job in fewer tokens. That is why cost per successful task is often more useful than raw spend.
If you want a broader market view instead of a model-by-model list, the value view is the right lens: it helps you think in terms of cost relative to capability, not just absolute price.
How to track AI spend without leaking your data
The cleanest setup is local-first. Run a tool that reads the usage logs your coding agents already keep on disk, calculates a 30-day cost table at API prices, and leaves the raw usage data on your machine. That gives you a useful answer without uploading prompts, code, or file names just to learn what a project cost.
For teams that want a dashboard, the sync flow is still privacy-aware. Only daily totals per agent and model are uploaded, not the underlying prompts or source material. That is the right tradeoff if you want visibility without turning observability into surveillance.
In practice, a good tracking setup should capture:
- Cost by provider, model, platform, and use-case
- Input, output, cached, and reasoning tokens
- Latency and success rate
- Estimated cost when the exact price is not known yet
That combination matters because token count alone is not enough. A low-token request that fails three times can be more expensive than a higher-token request that succeeds once. If you care about the economics of AI systems, success needs to be part of the bill.
How to think about blended prices and the AI Cost Index
Not every team wants to reason about separate input and output rates every time. Sometimes you just want a benchmark number that reflects a realistic mix of traffic. That is what the AI Cost Index is for, and it is reported as a blended 3:1 input:output price per 1M tokens.
The current Frontier basket is $4.64 per 1M tokens, and the Budget basket is $0.74 per 1M tokens. Those are not vendor list prices, they are benchmark baskets meant to make broad comparisons easier. If you are deciding whether your app should live in the frontier lane or the budget lane, that spread tells you a lot before you even look at a specific model.
Blended benchmarks are useful because they answer a different question than raw model pricing. They tell you what a realistic workload costs, not just what a single input or output token costs in isolation.
That is also why the index is useful for trend watching. If the frontier basket stays flat while individual models move around, you still get a stable high-level signal. If the budget basket stays low, you know there is still room for cheap, high-volume automation.
What developers should actually do next
If you are shipping an app, start with the cheapest model that reliably completes the task, then move up only when quality or latency demands it. If you are using agents internally, track spend by use-case, not just by vendor, so you can see which workflows are quietly eating your budget. And if you are comparing tools, compare the whole stack, not just the chat model in isolation.
The point is not to obsess over every fraction of a cent. The point is to stop guessing. Once you can see daily totals by agent and model, the expensive stuff gets obvious fast: long prompts, repeated retries, unnecessary output, and workflows that should have been cached or delegated to a cheaper model.
For a community-level view of how other developers are spending, the community data is a useful reality check. It helps you see whether your own usage is normal, noisy, or just wildly inefficient.
FAQ
Do I need an account to see my local AI spend?
No. You can run the local tracker and get a 30-day cost table without sending usage data anywhere. It reads the logs your coding agents already keep on your machine and computes cost locally at API prices.
What gets uploaded if I sync to a dashboard?
Only daily totals per agent and model are uploaded. Prompts, code, and file names are not uploaded. That keeps the dashboard useful without exposing project content.
Why not just use the vendor billing page?
Because vendor billing pages are siloed. If you use Claude Code, GPT, Gemini, and a couple of wrappers, you need one normalized view across everything. Otherwise you cannot tell which tool, model, or use-case is actually driving spend.
How to track this
To try it, run npx mytokentracker. It works locally, needs no account for the basic readout, and prints a 30-day cost table at API prices. If you want sync and dashboarding, create a free account and run npx mytokentracker init. It supports Claude Code, Codex, GitHub Copilot CLI, Antigravity, OpenCode, Amp, Qwen Code, and more. For installation details, see the install page.
Once you have the numbers, the pattern is usually obvious: a small set of agents and models account for most of the bill. That is the part worth optimizing, not the average token rate in the abstract.