Four AI Providers, Ten Keys, Zero Unified View. Sound Familiar?
Juggling OpenAI, Anthropic, Gemini, and OpenRouter? Here's what you lose without a unified project view — and what actually changes when you have one.
In 2024, many teams used one AI provider. They had an OpenAI key, a dashboard they checked occasionally, and a rough sense of their monthly bill.
In 2026, that's not what serious AI applications look like.
The modern stack uses GPT-4o for tasks that need deep reasoning. Claude for document work, where the long context window and precise instruction-following matter. Gemini Flash for volume — classification pipelines, support triage, anything that runs at scale where cost-per-request determines whether the feature is economically viable. And OpenRouter (or a similar abstraction) for routing, fallbacks, and experimental model switching without rewriting integrations.
That's four providers. Four dashboards. Four different billing units — tokens, characters, credits, API units. Four billing cycles that don't align. Four key management systems with no shared concept of what a "project" is.
This is the default state for any team that has been building with AI seriously for more than six months. And it creates a specific kind of problem that no individual provider dashboard can solve.
The Fragmentation Tax
Using the right model for each task is the correct decision — the cost math is compelling enough that engineers who've done it don't go back. But fragmentation has a cost. Let's make it specific.
You can't answer "how much did feature X cost this month?"
If your document processing pipeline uses Claude for extraction and GPT-4o mini for the final summarization pass, the cost is split between two providers. Anthropic's dashboard shows you the Claude spend. OpenAI's dashboard shows you the GPT-4o mini spend. Neither dashboard knows the other exists.
To answer "what did this pipeline cost in February?", you need to:
- Export billing CSVs from both providers
- Filter rows by date
- Identify which API keys belong to this feature
- Normalize to a common unit
- Sum them
That's a 20-minute task if everything is clean. In practice, it's 45 minutes with at least one "wait, is this the right key?" moment.
Different billing cycles make comparisons unreliable
OpenAI bills on a calendar month. Anthropic bills on your subscription anniversary. Google Cloud AI billing follows your GCP billing cycle. When you pull "this month's" numbers from three dashboards in the same session, you're looking at three different time windows and calling them comparable. They're not.
Keys for different features live in different places with no grouping
In a growing team, API keys proliferate. You have a key for production, a key for staging, a key someone created for a weekend experiment and never rotated. Provider dashboards don't let you say "these four keys all belong to the Document Pipeline project." You can name them, but the naming convention is something you invented — and it breaks the moment someone creates a key with a slightly different pattern.
A compromised key requires checking four places
If a key appears in a public repository, or your logs show unexpected usage patterns, incident response requires checking four dashboards to understand the blast radius. You piece this together across four interfaces, each with different log retention and different latency between request and billing record.
None of these are edge cases. They're the day-to-day overhead of operating a multi-provider AI stack without infrastructure built for it.
The Spreadsheet Trap
Teams that recognize this problem tend to converge on the same solution: a shared spreadsheet. Monthly cost tracking, one row per provider, manually updated.
It's not a bad instinct. But the spreadsheet has structural limitations that make it progressively less useful over time.
It's always behind. The person responsible updates it when they remember — which is usually not the same day the billing numbers are available.
Different team members update it inconsistently. One person records GPT-4o mini as a separate line. Another lumps all OpenAI costs together. After three months, the data is incomparable across rows.
It has no alerting. A spreadsheet can tell you what happened. It cannot tell you that Project X is tracking 40% over budget with 12 days left in the month, right now, while there's still time to act.
It can't distinguish signal from noise. Is $340 on the document pipeline this month high or low? The spreadsheet shows the number. It doesn't show you whether that's 20% above the rolling average, or whether one specific key spiked on the 14th.
The spreadsheet is a reasonable stopgap and a reliable dead end. Most teams outgrow it around the time they add their third provider or their third major feature with its own cost profile.
What a Unified View Actually Changes
The argument for a unified project view isn't that it's more convenient. It's that it changes what questions you can ask — and answer.
With all keys organized by project, across all providers, a specific kind of clarity becomes available.
You can see that Project X spent $342 this month. $198 from Anthropic on document extraction, $112 from OpenAI on summarization, $32 from Gemini on the triage pre-step. Not three separate numbers you're adding in your head. One number, one project, broken down on demand.
You set one budget for Project X — not three separate provider budgets you mentally reconcile. When Project X hits 70% of its budget, you get one alert, regardless of which provider the marginal spend came from. You investigate Project X. You find the extraction step is running 30% more volume than last week. You have something to act on.
You have one place to audit, rotate, or revoke keys. When a key needs to rotate — routine security hygiene, a team member departure, a suspected exposure — you go to one place, see every key associated with the project, and handle it. You don't reconstruct which providers the project even touched.
You can generate a spend report that makes sense to a non-engineer. Not three CSV exports with different column names and date ranges. A single view: here's what each project cost this month, here's how it breaks down by provider and model, here's how it compares to last month. The kind of thing you can send to a founder or CFO without a three-paragraph explanatory note.
The Reporting Reality
There's a specific moment this matters most: when someone with budget authority asks about AI costs.
"What are we spending on AI?" is a reasonable question from a founder, a CFO, or a board member. It's also a question that takes a surprising amount of time to answer well if your infrastructure isn't built for it.
The useful answer isn't "about $2,000/month across our providers."
The useful answer is: "We spend $800/month on document processing, which runs at roughly $0.12 per document and handles 6,700 documents a month. We spend $600/month on the support chat feature, which runs at $0.006 per conversation and handles 100,000 conversations. The remaining $600 is split between internal tooling and experimental work. Month-over-month, total spend is up 12%, driven entirely by document processing volume growth."
That answer comes from a system with per-project attribution and historical data. It doesn't come from four billing dashboards and a spreadsheet.
One Dashboard for All of It
The problem described in this post isn't new. It's the same fragmentation problem that appeared with cloud infrastructure, then with observability tooling, then with data warehousing. In each case, the solution was a unified layer that normalized different systems into a single view — not by replacing the underlying systems, but by aggregating and organizing what they emit.
AI API spend is at that inflection point now. The teams that have multiple providers are already dealing with this fragmentation. The teams about to scale from one provider to two will hit it soon.
This is exactly what we built API Lens to solve. One dashboard. All your keys, organized by project. One budget per project, across every provider it touches. Free to try.