How to Track Your AI Spending Across Multiple Providers (2026 Refresh)

If you use one AI provider, billing is annoying. If you use four, billing becomes a part-time job. A Claude subscription here, an OpenAI key there, a Gemini quota tied to a Google Cloud project, a router that bills you separately from the model calls it forwards. By the end of the month no single dashboard tells you what you actually spent on “AI”, and the surprises always land on the wrong side of zero.

I wrote a version of this guide in May 2026. Four months later enough has changed that the old advice would now actively mislead you. Gateways went from an observability nicety to a billing layer. The largest router in the category changed owners. Consumer subscriptions and API accounts moved further apart, not closer. This refresh covers what actually moved and the setup that still holds up when you have keys in five places.

What changed in 2026

Three structural shifts matter more than any single price table.

Gateways became the default place to meter spend. A year ago an LLM gateway was mostly a routing convenience. In 2026 Cloudflare AI Gateway ships spend limits, unified billing and per-request cost metrics as first-class features, LiteLLM is the self-hosted default for teams that want no third party in the request path, and OpenRouter remains the one-bill marketplace. The gateway is now where attribution happens, because it is the only layer that sees every call regardless of which provider served it.

Stripe acquired OpenRouter. Announced the week of August 17, 2026, at a reported price near $7.5 billion. The service itself did not change: same endpoint, same catalog, same credits. What changed is ownership. The layer that both chooses your model and meters your spend now sits inside a payments company whose stated thesis is token routing and usage-based billing. That is not a reason to panic, it is a reason to keep migration cheap. Never let a router become the only place your usage history exists.

The model surface got wider and cheaper at the same time. Current flagship rates sit in a band that spans roughly 40x from top to bottom. Here is the spread on the models most teams actually route between, per million tokens, as of September 2026:

Model	Input	Cached input	Output
gpt-6-astra	$10.00	$1.00	$50.00
gpt-5.6-sol	$4.00	$0.40	$20.00
Claude Opus 5	$5.00	$0.50	$25.00
Claude Sonnet 5	$2.00	$0.20	$10.00
gpt-5.6-terra	$2.00	$0.20	$12.00
gpt-5.6-luna	$0.20	$0.02	$1.20
Claude Haiku 4.5	$1.00	$0.10	$5.00

When the top and bottom of your routing table differ by 40x, the cost of a single misrouted request class is enormous, and you cannot see it without per-request attribution. A dashboard that says “you spent $4,800 last month” is useless if 80% of it came from one feature calling the wrong model.

Why provider dashboards are still not enough

Every provider ships a usage page. Anthropic Console, OpenAI Platform, Google Cloud billing, Mistral, DeepSeek, Groq. They all work in isolation. Three structural gaps survive into 2026.

1. Subscriptions and API are still billed separately. Claude Pro, Max and Team sit on a consumer billing flow. The Anthropic API sits on Console, on prepaid credits or postpaid invoicing. They do not aggregate. OpenAI is the same: ChatGPT plans in one portal, platform.openai.com in another. No provider has shipped a single view that unifies both.
2. Dashboards still lag. Spend updates within minutes; token and request counts can trail by a full day. If you deploy a buggy agent on a Friday, the export you pull Saturday morning may not include it.
3. Indirect spend is still invisible. Cursor, Windsurf, Claude Code, Copilot and every tool that forwards your prompts do not report the underlying call volume in a form you can read. You see a flat fee and a meter that counts “requests”, not dollars.

The four buckets

Before you pick tools, get the categories right. I still split AI spend into four buckets and reconcile them weekly.

Bucket 1: Direct API usage. Anthropic, OpenAI, Google AI Studio and Vertex, Mistral, DeepSeek, Groq, Together, Fireworks, Cerebras. This is the bucket that can spike from $40 to $4,000 over a weekend when a loop goes wrong, so it deserves the most instrumentation.

Bucket 2: Consumer and team subscriptions. Claude Pro, Max and Team, ChatGPT Plus, Pro and Team, Gemini Advanced, Perplexity Pro, GitHub Copilot, Cursor, Windsurf, Replit. Predictable individually, dangerous in aggregate. The risk is not overspend, it is forgetting which ones you still need.

Bucket 3: Cloud-hosted models. Bedrock, Vertex, Azure OpenAI, and inference platforms billed through your existing cloud account. This hides inside the cloud bill, usually under vague SKUs, and rarely appears in the same report your finance team uses for AI tools.

Bucket 4: Implicit AI inside SaaS. Notion AI, Linear AI, Intercom Fin, Salesforce Einstein, Atlassian Rovo. You did not buy an AI subscription, you bought a feature, and you are paying for inference somewhere upstream. Smallest per seat, hardest to audit.

Track only bucket 1 and you undercount badly. Track 1 and 2 and you still miss the cloud bill, which for any team running production agents is often the largest line.

What each dashboard gives you now

Anthropic Console. Per-key usage with daily granularity, broken down by model. Costs in USD with input, output, cache write and cache read tokens separated, which matters because cached input is billed at a fraction of standard input. Monthly spend limits per workspace and per key, email alerts at configurable thresholds, CSV export per month from the billing tab. There is still no cross-workspace rollup on the consumer side, so a company with several workspaces stitches them together by hand. In 2026 the practical bottleneck is Team and Enterprise seats, where usage credits and overflow spend live behind an admin view that is coarser than the API key view.

OpenAI Platform. Daily usage and cost by model, broken down by project. Projects remain the correct unit of allocation: one per team or product. Hard and soft limits are configurable per project. Exports are JSON or CSV. Image, audio, batch and fine-tuning usage are separated, which is useful because they bill on different units. The Agents API adds a wrinkle: no platform fee, but multi-agent fan-out grows your token count in ways a request-count view will not show.

Google. The messiest stack. Consumer Gemini subscriptions sit inside Google One. The Gemini API via AI Studio bills through a Google Cloud project. Vertex AI bills through the same project under different SKUs. If finance treats the whole Cloud bill as “infra”, AI spend disappears into it. Label resources aggressively and, once the number is material, pull the billing export into BigQuery and build one saved query.

Aggregators and gateways. This is where the most movement happened. Cloudflare AI Gateway’s core features (dashboard analytics, caching, rate limiting) are free on all plans, with persistent log storage capped at 100,000 logs total across all gateways on the Workers Free tier and 10 million per gateway on paid. It adds no per-token markup because you keep your own provider keys and billing relationship, and it now exposes cost metrics and spend limits. LiteLLM is free and open source with no markup, at the cost of hosting and on-call. OpenRouter is the only one of the three that resells inference, so its convenience shows up in the effective per-token price: no separate platform fee, but an embedded markup inside credit pricing.

That distinction is the one people get wrong. A gateway that resells inference (OpenRouter) and a gateway that proxies your own keys (Cloudflare, LiteLLM) look similar on a pricing page and behave completely differently in a cost report. The first gives you one bill and hides the markup. The second gives you your provider’s bill plus a free or near-free observability layer.

Subscription tools. Cursor, Windsurf, Claude Code, Copilot. They show a usage meter on their own terms and almost never show the dollar value of the calls they make. Fine while the cap holds. The moment you hit usage-based overage, you need to read how each “request” or “credit” maps to dollars, and that mapping changes more often than the price table does.

A minimal setup that scales

You do not need a FinOps platform on day one. You need one sheet, one logger, and a weekly habit.

1. One source of truth for subscriptions

A single sheet, one row per subscription: provider, plan, monthly cost, annual cost, renewal date, owner, purpose, last reviewed. Update on the first of the month. The value is not the data, it is the review. If a row has not been touched in three months and nobody remembers why it exists, cancel it.

2. Per-key logging on your side

Do not let any provider dashboard be your only record. Wrap your API calls with a thin logger that writes, per request: timestamp, provider, model, input tokens, output tokens, cached tokens, latency, request ID, and a tag for which feature made the call. Append to SQLite or a cloud table and compute cost at query time from a price table you keep current.

If you route through a gateway, this is largely free: Cloudflare AI Gateway and LiteLLM both emit per-request logs with token counts. Add the feature tag yourself, because no gateway knows your product’s internal geometry. That tag is what turns “model X cost $812 last week” into “feature Y caused 78% of it”.

3. Cloud spend with explicit labels

Through Bedrock, Vertex or Azure OpenAI, label every resource with team and product, then build one saved billing query filtered to AI SKUs and grouped by label. Run it weekly. The labels matter more than the query, because untagged spend in a shared cloud account cannot be attributed after the fact.

4. A weekly reconciliation

Fifteen minutes once a week: pull each dashboard’s week-to-date number, write it into the sheet, sum the buckets, compare to the same week last month. You are not auditing, you are looking for the line that moved. A number that doubled week over week is a question worth asking even when the absolute amount is small. That is how you catch a regression while it costs $50 instead of $5,000.

When to graduate to a tool

A spreadsheet plus a logger handles most teams up to roughly $5,000 to $10,000 a month. Past that the failure mode changes. You stop missing money and start missing patterns: which user, which prompt template, which hour, which downstream feature.

That is where a dedicated tracker earns its keep. It can be an internal dashboard built on your own logs. It can be a third-party tool that ingests provider exports. It can be a workspace like tokenkarma, which is built specifically for the case of one person or one team holding several subscriptions and several API keys at once. The goal is identical in every case: one screen that answers “what did we spend, on what, this week” without opening four dashboards.

What to look for, roughly in order of usefulness:

• Multi-provider ingestion through official exports or a gateway log stream, not scraped HTML.
• Per-feature or per-project attribution, not just per-key.
• Forecasting from your actual run rate, not a flat extrapolation of month-to-date.
• Anomaly alerts on rate of change, not only absolute thresholds. A jump from $5 to $50 a day is the early warning. A static $500 alert is the smoke alarm after the fire.
• A cost model that understands cached tokens and gateway markups, so the number it shows matches the invoice.

Common mistakes that cost real money

Leaving an old key in a forgotten script. A cron job from six months ago still calling an expensive model, still working, still billing. Rotate quarterly and pull the active key list from each provider. Anything you cannot identify, disable.

Confusing a subscription cap with a hard cap. Most consumer plans throttle you or downgrade the model rather than stopping. Most API accounts can hard-stop at a dollar amount, but the default is often a soft alert. Check the setting instead of assuming it.

Counting prepaid credits as spent the day you buy them. Credits are an asset until consumed. If finance books them as expense at purchase, your AI line swings for no operational reason. Track balance and consumption separately.

Ignoring cache hits. Cached input is billed at a fraction of standard input across Anthropic, OpenAI and Google. If your workload reuses long system prompts, cache pricing can shift a model comparison by 50% or more. Your log needs cached tokens as their own field or you cannot reason about it.

Treating a gateway as free. A proxy in front of your own keys is close to free. A router that resells inference is not: the markup lives inside the credit price, invisible unless you measure effective per-token cost against the provider’s list price. Do that measurement once a quarter.

Treating the cheapest model as free. Luna and Haiku class models are cheap enough that engineers stop thinking about them, right up until a retry loop or a multi-agent fan-out makes a thousand parallel calls. Cheap models reward sloppy throughput patterns. Give them the same attention you give the expensive ones.

A realistic target

The point of tracking AI spend is not to minimize it. It is to know what you are getting for it. A team that can say “this feature ships $4,200 a month of inference and returns $90,000 a month of revenue” has won the conversation. A team that says “I think we spend about $5k on AI, maybe more” has not.

Pick the buckets that apply to you. Stand up the logger, or put a gateway in front and read its logs. Hold the weekly reconciliation. Within a month you will know your number. Within three you will know where it goes. From there every other decision, which provider, which plan, which router, stops being a guess.

The tooling is the easy part. The habit is the hard part. Start with the habit today, not next quarter.