My AI API Cost Spreadsheet: 184 Models, Real Production Numbers

Look, my AI API Cost Spreadsheet: 184 Models, Real Production Numbers

I keep a spreadsheet. Not because I'm obsessive (okay, maybe a little), but because AI API pricing is genuinely confusing and the marketing pages lie to me constantly. After six months of running a side project that routes requests across multiple model providers, I have hard data on what I actually paid vs. what I would have paid going direct. This is that data, cleaned up and turned into something useful.

If you're picking between going direct to providers like OpenAI, DeepSeek, Anthropic, or going through an aggregator like Global API, I've got numbers for you. And yes, I'm aware there's a sample size issue here — this is n=1 on the personal project front. Treat it as a starting point, not gospel.

Why I Started Tracking This

Six months ago I shipped a small AI feature for a SaaS product. The kind of thing where users submit content, get a summary back, and we charge them money. Simple. Except — and this is the part nobody warns you about — every time I wanted to test a different model for cost or quality, I had to:

1. Sign up for a new provider account
2. Add a new API key
3. Write new integration code
4. Set up billing (some China-based providers wanted Alipay)
5. Track a new set of pricing tiers

So I built a wrapper. Then I routed everything through Global API. Then I started keeping the spreadsheet because the cost variance between options was larger than I expected.

The original "Enterprise Vs Startup AI API: Complete Guide" framing is a useful starting point — budgets really do look different at $50/month vs. $50,000/month — but that's only the first cut. The second cut is what you actually pay per token, and that's where the data gets interesting.

The Model Zoo Problem

184 models. That's the headline number from Global API. I haven't actually tested all 184 (sample size issue, again), but I have rotated through 23 of them across the past 6 months. Most of my actual production traffic came from three:

Add it up and I spent $296.35 over six months. Going direct to GPT-4o for the equivalent output volume would have run me roughly $11,854 (statistically, this is extrapolated from per-token pricing of $10.00/M output × volume). That's a 97.5% delta, statistically the same number the original guide points to. Correlation isn't causation, but when it's this lopsided, I stop debating semantics.

The interesting question isn't "is it cheaper?" — it obviously is. The interesting question is: under what conditions does the gap shrink, and when does direct provider access genuinely win?

What The Spreadsheet Actually Shows

Here's what six months of token tracking taught me, broken down by stage of project:

The Startup Curve (My Data + Extrapolation)

For the first three months I was at MVP scale. For the last three, somewhere between beta and launch.

Look at that row, the 97.5% delta is statistically suspicious — it's almost suspiciously consistent across scales. That's because both pricing scales linearly with volume. The ratio $0.25/M vs $10.00/M is roughly 1:40, so the savings magnitude is locked in regardless of your scale. What changes with scale is the absolute dollar figure, and that's where enterprise pain actually kicks in.

When you hit the "Growth" row, $1,250/month vs $50,000/month — that's a meaningful difference. That's the gap where you'd hire another engineer. That's the gap where you'd pursue compliance certifications. Aggregator routes preserve that economic gap at every size.

When Direct Provider Access Actually Wins

I want to be fair here. There are scenarios where the spreadsheet shows direct is better:

1. Negotiated enterprise rates. If you're at $50K+/month and you call OpenAI's enterprise sales team, you can get 30-40% discounts off posted rates. That closes the gap. Aggregators don't always match these, though Pro Channel often does.

2. Regulatory pinning. Some compliance regimes (certain EU data residency rules, HIPAA for healthcare, etc.) require your data to never leave a specific provider's infrastructure. Aggregators route through different physical infrastructure at different times. For these cases, direct is the only legally clean answer — unless your aggregator offers enterprise-grade data processing agreements.

3. Single-model deep specialization. If you're a startup that has decided "we only need DeepSeek V3.2 and we need its exact behavior," the integration overhead of using one direct provider is small. But — and this is the part people forget — you're locking yourself into one model. If a better one ships next quarter, you rebuild your integration.

For everything else, the correlation between "going through an aggregator" and "saving money + maintaining flexibility" is, in my dataset, very strong.

Enterprise Constraints: What The Data Doesn't Capture

When I talk to enterprise CTOs, the conversation shifts from $/M tokens to SLA, uptime, and audit trails. The original guide's enterprise section calls this out well — 99.9% uptime SLA, dedicated capacity, custom DPAs, Net-30 invoicing. I haven't personally run a $50K/month system through Global API Pro Channel, so I can't give you first-person data on SLA breaches.

But I can show you what the gap looks like for an enterprise that does try to DIY their multi-model setup:

The thing I noticed talking to enterprise folks is that 50 req/min on the free tier is a non-starter for any production system at scale. Free-tier numbers are basically "evaluation only." Pro Channel removes that constraint, and that's where the comparison breaks from a pure $/token analysis into a "total cost of operations" analysis.

Sample size caveat: I only have detailed conversations with 4 enterprise teams about this. Not statistically significant, but the pattern was consistent.

My Hybrid Architecture (With Code)

Here's the routing layer I built. It's small, it's dumb, and it works across all 184 models via a single endpoint:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["GLOBAL_API_KEY"],
    base_url="https://global-apis.com/v1"
)

# Tier 1: cheap default for most requests
def cheap_complete(prompt: str) -> str:
    response = client.chat.completions.create(
        model="deepseek-ai/DeepSeek-V4-Flash",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=500
    )
    return response.choices[0].message.content

# Tier 2: fallback when cheap tier is rate-limited or times out
def fallback_complete(prompt: str) -> str:
    response = client.chat.completions.create(
        model="Qwen/Qwen3-32B",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=500
    )
    return response.choices[0].message.content

# Tier 3: premium for high-stakes requests
def premium_complete(prompt: str) -> str:
    response = client.chat.completions.create(
        model="deepseek-ai/DeepSeek-R1",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=1000
    )
    return response.choices[0].message.content

# The router
def smart_route(prompt: str, tier: str = "cheap") -> str:
    try:
        if tier == "cheap":
            return cheap_complete(prompt)
        elif tier == "fallback":
            return fallback_complete(prompt)
        elif tier == "premium":
            return premium_complete(prompt)
    except Exception as e:
        # Auto-failover — fall through tiers
        if tier == "cheap":
            return fallback_complete(prompt)
        raise e

The auto-failover is the bit that matters. If DeepSeek V4 Flash is having a bad day (it happens — I saw 23 minutes of degradation in month 4), the wrapper falls through to Qwen3-32B at $0.28/M. That's still 96% cheaper than going direct to GPT-4o.

I also keep code paths ready for Pro Channel when/if I cross into enterprise territory:

# Pro Channel example — same API, dedicated backend
client = OpenAI(
    api_key="ga_pro_xxxxxxxxxxxx",
    base_url="https://global-apis.com/v1"
)

# Access Pro-tier models with guaranteed capacity
response = client.chat.completions.create(
    model="Pro/deepseek-ai/DeepSeek-V3.2",  # Dedicated instance
    messages=[{"role": "user", "content": "Critical enterprise analysis"}]
)

Same SDK. Different backend. That's the whole pitch. Most enterprise migrations I've heard about are vastly more painful than api_key= + base_url= swaps.

Hidden Costs I Didn't Expect

The spreadsheet has columns you wouldn't predict. Let me give you three:

1. Engineering time on multi-provider abstractions. I burned roughly 8 hours writing my own router before deciding to standardize on the aggregator. If I'd skipped that detour and gone aggregator-first, I would have saved ~$800 in opportunity cost at my blended hourly rate. Statistically a small number for a startup, but it added up.

2. Dead credits at direct providers. If you go direct and switch providers mid-month, you might leave credits on the table. The aggregator's "credits never expire" claim is one of the few genuinely useful differentiators in this space. I had $43 sitting unused in a WeChat-pay-only DeepSeek account for 2 months before I gave up.

3. Compliance review cycles. When my product started showing up in conversations with healthcare-adjacent users, I had to answer "where does data flow?" Switching the architecture diagram from "single provider" to "aggregator with DPA" added one vendor review. Enterprise Pro Channel makes that review faster because they have docs ready.

What I'd Actually Recommend

Given my six-month cost spreadsheet, here are my recommendations — qualified by sample size as always:

For startups at $10–500/month: Use the standard aggregator tier. Don't sign direct contracts. Don't pre-purchase credits. Don't worry about Pro Channel until you actually need an SLA (you won't need one until you're past $2K/month).

For startups at $500–5,000/month: Same as above, but add the hybrid router pattern. Pay the engineering cost once. Save operational headache forever.

For enterprises at $5,000–50,000+/month: Start a procurement conversation with Global API Pro Channel and your current direct provider. Compare. The 99.9% SLA, dedicated capacity, and Net-30 invoicing will likely tip the scale, especially once you account for the multi-model flexibility that direct providers can't give you.

For everyone: Don't sign annual commitments until you have at least 3 months of actual usage data. Pre-commitments only make sense once you have statistical confidence in your workload pattern.

The Takeaway

The "direct