Here’s the thing about running AI agents at scale — nobody talks about the bill until it arrives. And when it does? It’s usually a lot worse than expected.
I sat down with the actual pricing pages this week. Every provider. Every tier. And honestly? The gap between the cheapest and most expensive option isn’t just big. It’s the kind of gap that turns a $200 monthly bill into $15,000 if you pick wrong.
Let’s go through it. Provider by provider, number by number, so you know exactly what you’re signing up for before you scale.
DeepSeek — The Price Floor
DeepSeek’s V4 series sets the floor for what API inference can cost in mid-2026. Their V4 Flash model charges $0.14 per million input tokens and $0.28 per million output tokens — and that drops to $0.0028 per million on cache hits. Yes, you read that right. Less than a third of a cent per million tokens when your prompts hit the cache.
The Pro tier costs more: $0.435 per million input, $0.87 per million output, and $0.003625 on cache hits. Still absurdly cheap compared to anyone else. But there’s a tradeoff. Concurrency caps at 2,500 for Flash and 500 for Pro. If you’re running hundreds of parallel agent instances hammering the API simultaneously, you’ll feel those limits.
Context window: 1 million tokens with up to 384K output. Tool calls, JSON mode, and chat prefix completion are all supported. Both models support a thinking mode for reasoning-heavy agent tasks, though thinking tokens cost the same as output tokens.
Source: DeepSeek API Pricing Docs
OpenAI — The Premium Tier
OpenAI’s latest lineup is fast and capable. It’s also expensive. Really expensive.
GPT-5.5, their flagship, runs $5 per million input tokens and $30 per million output. That’s roughly 107x more expensive on output than DeepSeek V4 Flash. The Pro variant jumps to $30 input and $180 output — you don’t want to know what that costs at 100,000 requests per day.
But OpenAI’s range is wider than most people realize. GPT-5.4-mini ($0.75 input, $4.50 output) and GPT-5.4-nano ($0.20 input, $1.25 output) bring the cost down significantly. Nano is competitive with mid-tier pricing from other providers — $0.20 per million input is actually reasonable for what you get. Cached input drops to $0.02 per million on Nano, which makes repetitive agent workloads far more affordable.
Context length varies by model tier, with the 5.5 series supporting longer contexts at higher price points. Batch API pricing offers a 50% discount — half off standard rates if you can handle async processing with completion times up to 24 hours.
The thing is, OpenAI’s agent tooling is the most mature. If your agents use built-in web search, code interpreter, or file search, those tools are billed separately — $10 per 1,000 web search calls, $2.50 per 1,000 file search calls, on top of token costs.
Source: OpenAI Platform Pricing
Anthropic — Enterprise Agent Pricing
Anthropic positions Claude models as the premium agent platform, and the pricing reflects that. Claude Sonnet 5 — the current workhorse for most agent deployments — is priced at $2 per million input and $10 per million output under introductory pricing through August 2026. After September 1, it shifts to $3/$15.
Claude Haiku 4.5 is the budget option at $1 per million input and $5 per million output — with cache hits at $0.10. It’s the cheapest Anthropic entry point, and for straightforward agent tasks like classification or structured extraction, it’s more than capable.
Claude Opus 4.8, their top-tier reasoning model, runs $5 input and $25 output. Cache hits at $0.50 per million. This is where you go when accuracy matters more than cost — complex multi-step agent reasoning, legal document analysis, things where a hallucination costs real money.
Important caveat: Opus 4.8 and newer Claude models use an updated tokenizer that produces roughly 30% more tokens for the same text. So the effective cost is about 30% higher than the published per-token rates suggest. Anthropic documents this openly, but it’s easy to miss if you’re just comparing tables.
Prompt caching with dedicated cache writes costs more (1.25x for 5-minute, 2x for 1-hour cache), but cache hits are consistently 10% of base input pricing. For agents that send similar system prompts and tool definitions across every request, this adds up to real savings.
Source: Anthropic Claude Pricing
Google Gemini — The Vertex Factor
Google’s Gemini models on Vertex AI are priced competitively but come with a twist: pricing depends on whether you’re using global or regional endpoints. Regional and multi-region endpoints carry a 10% premium.
Gemini 3.5 Flash is the sweet spot for agent workloads: $1.50 per million input and $9 per million output at global pricing. Cached input drops to $0.15 per million. It handles text, images, video, and audio in a single model — which simplifies agent architecture if you’re processing mixed media.
Gemini 3 Flash Preview is the cheaper option: $0.50 per million input and $3 per million output. And Gemini 3.1 Flash-Lite goes even lower: $0.25 per million input and $1.50 per million output. That’s within striking distance of DeepSeek territory, with Google’s infrastructure behind it.
Flex and batch pricing cuts costs further: standard pricing gets a 50% discount on Flex, and batch brings it even lower — with Gemini 3.5 Flash batch input dropping to $0.75 per million and output to $4.50 per million. If your agent workload can tolerate delayed processing, the savings are substantial.
Source: Google Vertex AI Pricing
xAI Grok — The Dark Horse
Grok 4.3, xAI’s current API offering, sits in an interesting middle ground: $1.25 per million input and $2.50 per million output with a 1-million-token context window. Batch API discounts range from 20% to 50% off standard rates, with responses typically within 24 hours.
The pricing is straightforward — no separate cache-hit tiers, no tokenizer multipliers, no endpoint premiums. What you see is what you pay. For agents that need a 1M context window but don’t want DeepSeek’s rate limit constraints, Grok offers a compelling alternative.
Their Code API model (grok-build-0.1) runs $1 per million input and $2 per million output — slightly cheaper for pure code-generation agent tasks. Server-side tools like web search ($5 per 1,000 calls) and code execution ($5 per 1,000 calls) are billed separately on top of token costs.
Source: xAI API Pricing
The Open-Source Option — Self-Hosted Inference
If you’re running agents at serious scale — hundreds of thousands of requests per day — self-hosting becomes a conversation worth having. Models like Llama 4, Mistral Large, and Qwen 3 are available under permissive licenses.
But here’s the catch. Self-hosting means you’re paying for GPU compute directly. A single H100 instance on a cloud provider runs $2-4 per hour reserved, or $5-8 on-demand. At 500 tokens per second throughput, that’s roughly 30 million tokens per hour. Even at $3/hour, that works out to about $0.10 per million tokens — comparable to DeepSeek’s API pricing but without rate limits.
Except it’s never that simple. You need redundancy. Load balancing. Monitoring. Cold starts. Idle capacity during low-traffic periods. The real cost of self-hosting is typically 2-3x the pure compute number once you factor in ops overhead. For teams without dedicated ML infrastructure engineers, the managed API is usually cheaper in practice — even if the per-token math looks worse.
Source: Hugging Face Model Hub, cloud provider GPU pricing pages
Cost Per Million Tokens — The Raw Numbers
| Model | Input / 1M | Output / 1M | Cache Hit |
|---|---|---|---|
| DeepSeek V4 Flash | $0.14 | $0.28 | $0.0028 |
| DeepSeek V4 Pro | $0.435 | $0.87 | $0.0036 |
| Gemini 3.1 Flash-Lite | $0.25 | $1.50 | $0.025 |
| GPT-5.4-nano | $0.20 | $1.25 | $0.02 |
| Gemini 3 Flash Preview | $0.50 | $3.00 | $0.05 |
| Grok 4.3 | $1.25 | $2.50 | N/A |
| Claude Haiku 4.5 | $1.00 | $5.00 | $0.10 |
| Gemini 3.5 Flash | $1.50 | $9.00 | $0.15 |
| GPT-5.4-mini | $0.75 | $4.50 | $0.075 |
| Claude Sonnet 5 | $2.00 | $10.00 | $0.20 |
| GPT-5.4 | $2.50 | $15.00 | $0.25 |
| Claude Opus 4.8 | $5.00 | $25.00 | $0.50 |
| GPT-5.5 | $5.00 | $30.00 | $0.50 |
All prices in USD per million tokens. Cache hit pricing requires prompt caching to be configured — it’s not automatic. Grok does not publish separate cache-hit pricing as of July 2026. Gemini prices shown are global endpoint pricing; regional and multi-region endpoints add 10%.
What Scale Actually Costs
Let’s make this concrete. Imagine a typical agent request: 2,000 input tokens (system prompt, tool definitions, conversation context) and 500 output tokens per turn. A multi-turn agent interaction might run 5 turns, so 10,000 input and 2,500 output total per task.
100 Tasks Per Day
This is a pilot phase — the kind of thing you run for a week to prove an agent works before scaling.
| Model | Daily Cost | Monthly Cost |
|---|---|---|
| DeepSeek V4 Flash | $0.21 | $6.30 |
| GPT-5.4-nano | $0.51 | $15.30 |
| Grok 4.3 | $1.88 | $56.40 |
| Claude Sonnet 5 | $4.50 | $135.00 |
| GPT-5.5 | $12.50 | $375.00 |
1,000 Tasks Per Day
This is where it starts to matter — a modest production deployment serving internal users or early customer-facing features.
| Model | Daily Cost | Monthly Cost |
|---|---|---|
| DeepSeek V4 Flash | $2.10 | $63.00 |
| GPT-5.4-nano | $5.13 | $153.90 |
| Grok 4.3 | $18.75 | $562.50 |
| Claude Sonnet 5 | $45.00 | $1,350.00 |
| GPT-5.5 | $125.00 | $3,750.00 |
10,000 Tasks Per Day
Now we’re talking real money. This is a serious production deployment — customer support automation, document processing pipelines, or multi-agent research systems.
| Model | Daily Cost | Monthly Cost |
|---|---|---|
| DeepSeek V4 Flash | $21.00 | $630.00 |
| GPT-5.4-nano | $51.30 | $1,539.00 |
| Grok 4.3 | $187.50 | $5,625.00 |
| Claude Sonnet 5 | $450.00 | $13,500.00 |
| GPT-5.5 | $1,250.00 | $37,500.00 |
100,000 Tasks Per Day
Enterprise scale. If you’re here, you’ve probably got a dedicated budget line and a procurement team involved.
| Model | Daily Cost | Monthly Cost |
|---|---|---|
| DeepSeek V4 Flash | $210.00 | $6,300.00 |
| GPT-5.4-nano | $513.00 | $15,390.00 |
| Grok 4.3 | $1,875.00 | $56,250.00 |
| Claude Sonnet 5 | $4,500.00 | $135,000.00 |
| GPT-5.5 | $12,500.00 | $375,000.00 |
At 100K tasks per day, the gap between DeepSeek V4 Flash and GPT-5.5 is roughly $368,700 per month. That’s not a typo.
Batch Pricing — The Cheaper (Slower) Option
Every major provider offers batch processing at a discount — typically 50% off standard rates. OpenAI, Anthropic, Google, and xAI all have batch APIs where you submit jobs and get results within 24 hours. DeepSeek doesn’t advertise a separate batch tier, but their base pricing is already low enough that it arguably doesn’t need one.
The tradeoff is latency. If your agent needs real-time responses — a customer chatbot, a live trading signal — batch doesn’t work. But for overnight document processing, data labeling, report generation, or training data synthesis? Batch pricing cuts your bill in half with almost no downside.
Google’s Flex tier offers a middle ground: roughly 50% off standard pricing with better throughput than full batch, giving you responses within minutes instead of hours. It’s a good fit for agent workflows that need faster than batch but don’t require real-time speed.
Hidden Costs That Blow Up Your Budget
The per-token price is the headline number. It’s also not the whole story.
Rate limits. DeepSeek is absurdly cheap but caps at 2,500 concurrent requests for Flash. If your agent fleet spikes to 5,000 parallel calls, half get throttled. It enters a retry loop. That burns tokens. Then it gets throttled again. Enters a death spiral that burns your quota and produces nothing. OpenAI and Anthropic have higher or negotiable limits, but you pay for the privilege — and they still have limits. At 100K tasks per day with 5-turn agent loops, you’re doing 500K API calls. Even with concurrency management, you’ll brush against rate limits on every provider at that scale.
Tool call costs. OpenAI charges $10 per 1,000 web search calls. xAI charges $5 per 1,000 for web search, X search, and code execution. Anthropic doesn’t charge for tool calls separately — they’re just part of the token flow. But agents that lean heavily on tool use will generate far more tokens than simple chat, because every tool definition, every function result, and every reasoning step adds to the context window. A tool-heavy agent can easily consume 3-5x the tokens of a chat-only interaction.
Context bloat. Every turn in a multi-turn agent conversation adds tokens — the user message, retrieved documents, previous responses, tool results, system prompts. By turn 7 you’re at 90,000 tokens and climbing. That’s thousands of input tokens per turn that you’re paying for repeatedly. The cheapest model on the planet gets expensive when you’re stuffing 150K tokens of context into every call because you haven’t implemented proper context pruning.
Multi-agent architectures. The 327% growth in multi-agent deployments that Databricks tracked isn’t free. When one orchestrator agent calls three specialist agents, each with their own context and tool definitions, your total token consumption multiplies. A single user query that triggers a 3-agent chain can burn 30,000+ tokens before producing a single output word.
Verdict — What You Should Actually Use
Let’s cut through the numbers and get practical.
Budget under $100/month (prototyping, side projects): DeepSeek V4 Flash. At $6/month for 100 tasks per day, you can iterate endlessly without watching the meter. Combine with aggressive prompt caching and you’re spending pocket change. The concurrency limit won’t matter at this scale.
Budget $100-$1,000/month (small production, internal tools): DeepSeek V4 Flash or GPT-5.4-nano. Nano costs roughly 2.5x more but gives you OpenAI’s ecosystem — the tool ecosystem, the SDKs, the monitoring, and the bigger community. For 1,000 tasks per day, Nano runs about $154/month. Flash runs $63. The $90 difference buys you the OpenAI platform, which might be worth it depending on your stack.
Budget $1,000-$10,000/month (serious production, customer-facing): Grok 4.3 or Claude Sonnet 5. At this tier you’re doing 1,000-10,000 tasks per day and quality starts to matter more than pennies per token. Sonnet 5’s agent performance is genuinely strong, and Anthropic’s tool-use architecture is purpose-built for multi-turn agents. Grok offers competitive pricing with a 1M context window and simpler pricing structure.
Budget $10,000+/month (enterprise, high-stakes): Claude Opus 4.8 or GPT-5.5. When a hallucination costs more than the API call, you pay for reliability. Factor in the Anthropic tokenizer’s 30% token inflation and negotiate enterprise pricing — at this volume, list prices are negotiable. Google’s Gemini 3.5 Flash with Flex tier is also worth evaluating here: $0.75 input, $4.50 output at batch pricing, with Google’s infrastructure reliability.
And here’s the thing nobody mentions: the model you ship with doesn’t have to be the model you scale with. Start expensive during prototyping — build your prompts, tune your agent logic, prove the thing works with GPT-5.5 or Claude Sonnet 5 where debugging is easier. Then swap to a cheaper model for production when the logic is stable. The per-token cost difference between development and production is often 50-100x, and you’re doing 100x fewer calls during dev anyway. Optimize for developer speed first, cost second.
Most teams do it backwards. They pick the cheapest model on day one, spend weeks fighting quirky outputs and missing tool calls, then never ship. Spend the extra $200 on development tokens. Ship something that works. Then optimize the bill.
Sources: DeepSeek API Pricing (July 2026), OpenAI Platform Pricing (July 2026), Anthropic Claude Pricing (July 2026), Google Vertex AI Pricing (July 2026), xAI Grok API Pricing (July 2026). Scenario calculations based on 2,000 input + 500 output tokens per agent turn, 5-turn multi-agent interactions. Actual costs will vary with prompt design, tool usage, and caching strategy.