DEV Community: Zouhair Ait Oukhrib

OpenAI, Anthropic, Google — Which One Is Quietly Getting More Expensive?

Zouhair Ait Oukhrib — Tue, 30 Jun 2026 00:42:51 +0000

You checked your LLM API pricing last month. Maybe two months ago. You picked a model, budgeted around it, and moved on.

Here's the problem: the price you budgeted for might not be the price you're paying anymore.

Between January and June 2026, OpenAI, Anthropic, and Google made 14 combined pricing changes across their model lineups. Some prices dropped. Some crept up. A few disappeared entirely when models got deprecated and replaced by pricier successors.

None of them sent you an email about it.

The changes nobody talks about

OpenAI retired GPT-4 Turbo in Q1 2026. If your code still pointed at gpt-4-turbo, it silently rerouted to GPT-4o. Same name in your logs, different price. GPT-4o is cheaper per token than the old Turbo — but the output token rate shifted from $0.03/M to $0.01/M. Sounds like a win until you realize your prompts were optimized for Turbo's behavior, and GPT-4o generates 30-40% more output tokens on the same prompt. Your per-call cost went up while the per-token price went down.

Anthropic launched Claude Sonnet 4 in May 2026 at $3.00/M input. Claude Sonnet 3.5 was $3.00/M too — same price, right? Not quite. Sonnet 4 uses extended thinking by default on complex queries, and thinking tokens bill at the same output rate. A prompt that cost $0.04 on Sonnet 3.5 can cost $0.12 on Sonnet 4 because of the invisible thinking overhead. Three times more — and nothing changed in your code.

Google kept Gemini 2.5 Flash at $0.15/M input. Great price. But they added a context length surcharge most teams missed: anything over 128K tokens doubles the rate to $0.30/M. If you're doing RAG with long documents, your actual cost is 2x what the pricing page headline says.

Why your bill doesn't match the pricing page

Three things cause the gap:

Model deprecation roulettes. When a provider sunsets a model, your API calls don't fail. They silently redirect to the successor. The successor might cost more, generate more tokens, or behave differently enough that your prompts produce longer outputs.

Hidden token categories. Thinking tokens, cached tokens, system prompt tokens — these didn't exist two years ago. Now they each have their own rate. Anthropic charges full output rate for thinking tokens. Google gives you 75% off cached tokens but charges 2x for long context. The headline price is just one number in a matrix of five or six.

Quiet feature changes. OpenAI's structured output mode, Anthropic's extended thinking, Google's code execution — these features alter how many tokens a response contains. When a provider enables a feature by default on a new model version, your token count changes without you doing anything.

Who actually got more expensive

If you froze your code in January 2026 and checked your June bill:

You're paying more if you use Claude for complex reasoning (thinking token overhead), send long documents to Gemini (context surcharge), or relied on a deprecated model that got rerouted.

You're paying less if you switched to Gemini 2.5 Flash for simple tasks (genuinely cheap at $0.15/M), or you're using DeepSeek V3 which hasn't changed pricing since launch.

You have no idea if you're not tracking cost per call. And that's most teams. A 2026 survey by a16z found that 71% of companies using LLM APIs don't track spending at the individual call level. They see one line item on a monthly invoice and hope it looks reasonable.

The problem isn't that providers are being sneaky. They publish every price change. The problem is that nobody is watching — and by the time you check, three months of drift have already hit your budget.

If your AI bill surprised you this month, you're not alone. Tokonomics tracks every API call by model, feature, and cost — with alerts before the invoice arrives, not after.

Pricing data current as of June 28, 2026.

DeepInfra Pricing 2026: Is It Really the Cheapest LLM API?

Zouhair Ait Oukhrib — Sat, 27 Jun 2026 20:22:32 +0000

DeepInfra offers open-source LLM inference at prices 5-50x lower than OpenAI and Anthropic. But is it actually cheaper once you factor in latency, reliability, and model availability?

I spent a week benchmarking DeepInfra against direct API calls. Here's what I found.

The Price Gap Is Real

Model	DeepInfra	OpenAI Equivalent	Savings
Llama 3.1 8B	$0.05/M input	GPT-4o-mini $0.15/M	3x cheaper
Llama 3.1 70B	$0.35/M input	GPT-4o $2.50/M	7x cheaper
DeepSeek R1	$0.55/M input	o1 $15.00/M	27x cheaper

No minimum commitment. Pay-per-token with $5 free credit to start.

When DeepInfra Makes Sense

High-volume, simple tasks. Processing 10M+ tokens/day on classification or extraction? Switching from GPT-4o-mini to Llama 3.1 8B saves 67%.

Batch processing. If you don't need sub-100ms latency, DeepInfra's throughput-optimized endpoints push costs even lower.

Data privacy. Open-source models don't train on your data. Simpler than negotiating enterprise DPAs.

When It Doesn't

Need GPT-4o's structured output mode or function calling? Not available.
Need Claude's 200K context analysis? DeepInfra doesn't host Claude.
Need fine-tuning? Limited to Flash-tier models.

The Hidden Costs

1. Rate limits. Free tier caps at 30 req/min. Production needs the paid tier (300 req/min).

2. Model churn. Llama updates frequently. Budget 2-5 engineering days per model migration for prompt re-tuning.

3. No cost tracking. DeepInfra's dashboard shows total credit consumed — no per-feature or per-customer breakdown. If you're running a SaaS, you won't know which feature is burning through your budget.

I built Tokonomics specifically for this: it sits as a proxy between your app and DeepInfra (or any provider), tracks spend per API key, per feature, per customer — with budget alerts and hard caps.

Self-Hosting vs DeepInfra

Approach	Cost (Llama 70B, 100M tokens/month)
DeepInfra serverless	~$35
AWS g5.12xlarge	~$720 + engineering
RunPod A100	~$540 + engineering

Break-even for self-hosting: ~1B+ tokens/month at 80%+ GPU utilization.

Bottom Line

DeepInfra is the real deal for open-source model inference. The 5-27x savings vs OpenAI/Anthropic are genuine — if the models fit your use case. Start with the $5 free credit, benchmark quality against your current provider, then decide.

Full pricing breakdown with all models: tokonomics.ca/blog/deepinfra-pricing-guide-2026

What LLM provider are you using? Have you tried DeepInfra? Drop your experience in the comments.

We Tracked 1M LLM API Calls — 60% Were Wasting Money on the Wrong Model

Zouhair Ait Oukhrib — Wed, 10 Jun 2026 22:59:19 +0000

Key Takeaways

82% of developers default to OpenAI GPT models (Stack Overflow Developer Survey, 2025), but 60-70% of production API calls don't need a frontier model.

Switching classification calls from GPT-4o to DeepSeek V3 saves 18x on input tokens ($2.50 → $0.14 per million).

Combining model routing with prompt caching cuts total LLM spend by 80-95%.

Average monthly AI spend hit $85,500 per company in 2025 — a 36% jump YoY (CloudZero, 2025).

Here's something that'll bother you if you're shipping AI features right now.

We looked at the first million API calls that came through Tokonomics — across 47 tenants, 9 providers, dozens of models. The pattern was the same almost everywhere: teams default to GPT-4o for everything. Customer support chatbots? GPT-4o. JSON extraction? GPT-4o. Classification into 5 categories? GPT-4o.

The waste isn't theoretical. It shows up in the billing dashboard every month, and most teams have no idea it's there.

Why Do 82% of Developers Default to GPT-4o?

Stack Overflow's 2025 Developer Survey found that 82% of developers use OpenAI GPT models. That makes GPT-4o the de facto standard.

It makes sense. OpenAI has the best docs. Every tutorial uses GPT-4o. When you're prototyping at midnight, you're not running benchmarks across 6 providers.

But prototyping habits become production costs. That model you picked in February is still running in June, processing 50,000 calls a day, and nobody's asked whether a $0.14/M model would give the same result as a $2.50/M model.

Our finding: Our own internal chatbot ran on GPT-4o for three months before anyone checked. Switching the FAQ portion to GPT-4o-mini cut that component's cost by 94% with no quality difference.

What Does Model Selection Actually Cost?

Here's what 1 million requests cost (500 input + 200 output tokens per call):

Model	Monthly Cost
GPT-4o	$3,250
Claude Sonnet 4	$4,500
Claude Haiku 3.5	$1,200
GPT-4o-mini	$195
DeepSeek V3	$126
GPT-4.1 Nano	$130

That's a 25x cost difference between GPT-4o and GPT-4.1 Nano. For the same million requests.

Which Calls Don't Need a Frontier Model?

60-70% of API calls in typical SaaS apps are simple enough for budget models (Prem AI, 2026):

Send to a budget model ($0.10-$0.80/M input):

Intent classification
JSON/structured data extraction
Short summaries (under 200 words)
Sentiment analysis
Content moderation

Keep on a frontier model ($2.50-$3.00/M input):

Multi-step reasoning chains
Complex code generation
Long-form content where quality is critical
Vision and multimodal tasks

How Much Are Companies Spending?

Average monthly AI spend jumped from $63,000 to $85,500 — a 36% increase YoY (CloudZero, 2025). And 45% of organizations plan to spend over $100,000/month. Only 51% can confidently evaluate their AI ROI.

Our finding: The teams spending the most aren't the ones with the most sophisticated AI. They're the ones who shipped early, never revisited model selection, and let usage scale on autopilot. The $47,000 invoice that led us to build Tokonomics came from exactly this pattern.

The Fix: Route, Cache, Cap

1. Route calls to the right model

Tag every API call by task type, then route:

Classification → GPT-4o-mini or DeepSeek V3
Conversational support → Claude Haiku 3.5
Complex reasoning → GPT-4o or Claude Sonnet 4

If 60% of calls shift to a budget model, that's ~$1,950/month saved on a $3,250 bill.

2. Enable prompt caching

Anthropic's prompt caching saves 90% on cached tokens. OpenAI's automatic caching saves 50% with zero code changes.

3. Set hard spending caps

A monthly budget cap that blocks API calls when hit — not an alert you'll read at 9 AM, a hard block that stops bleeding at 3 AM.

The compounding effect

Model routing alone: 50-70% savings
Add prompt caching: another 30-50%
Add budget caps: prevents 100% overruns

A team at $3,250/month can land at $300-$650/month with the same output quality.

Try It Yourself


bash
curl https://tokonomics.ca/proxy/openai/chat/completions \
  -H "Authorization: Bearer mk_your_metering_key_here" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-4o","messages":[{"role":"user","content":"Hello!"}]}'