The moment you stop using AI as a chat and start putting it inside your code, the model stops being a browser tab and becomes a bill. And that bill can be three cents a month or three thousand euros, depending on which API you pick and how you use it. The gap between one provider and another, for the same task, can be 20 to 1.
The catch is that the map shifts every few months: new models ship, prices drop, aggregators appear. This guide is a 2026 snapshot so you understand how billing works, which provider wins at what, and which to choose for your case — no marketing, written for the person who's going to write the code.
Heads up
The exact figures for each API move month to month, almost always downward. Here we use ballpark ranges verified mid-2026. Before locking a budget, confirm the number on the provider's official pricing page: it's the only thing that doesn't expire.
Why compare APIs (instead of grabbing the first one)
The temptation is to use the API of the brand you already know —probably OpenAI— and forget about it. It works, but it leaves money and speed on the table. Three reasons to compare before you commit:
- Cost scales with volume. In a prototype it doesn't matter. When you're processing millions of tokens a day, a $2-per-million difference is the line between the project being profitable or not.
- Not every task needs the best model. Classifying an email, summarizing text or labeling data is handled fine by a cheap model. Reserving the flagship for those tasks is burning budget.
- Speed is a feature. If your AI answers a user in real time, 200 tokens per second versus 800 changes the experience completely. Some providers specialize in exactly that.
The right question isn't "which is the best API?" but "which is the best for this specific task?". And to answer it, you first have to understand the bill.
How billing works: input and output tokens
AI APIs don't bill by word or by request. They bill by token. A token is a fragment of text —roughly 4 characters or three-quarters of a word in English—. The phrase "Hello, how are you?" is about 6 tokens.
What matters, and what almost nobody looks at first, is that two things are billed separately:
- Input: everything you send the model. Your prompt, the system instructions, and —this is key— all the context you carry: the conversation history, the documents you pass it, tool results. In an agent, input grows on every loop.
- Output: what the model generates as a response.
And here's the trick that blows up bills: output costs 4 to 6 times more than input with nearly every provider. A model at $3 input might be $15 output. That's why an API that "looks cheap" if you only check the input can cost you dearly if it generates long answers.
Tip
Practical rule for estimating cost: count how many output tokens you expect per request and multiply them by the output price, which is the one that dominates. If your responses are long (reports, code, writing), output rules the bill. If you only classify or extract data, input weighs more because you feed it a lot of context and little text comes out.
Two more details that genuinely lower the bill when you use them:
- Prompt caching. If you resend the same block of context across many requests (a manual, a long system prompt), nearly every provider charges it at a tenth of the normal price from the second time on. In apps with fixed context, it's the single biggest savings lever.
- Batch mode. If you don't need the answer instantly, batch processing (up to 24 h turnaround) usually costs half on OpenAI, Anthropic and Google. Perfect for crunching bulk data overnight.
Provider by provider
OpenAI (the GPT-5 family)
The industry's default provider, and for a reason. Its range goes from tiny, dirt-cheap models (the "nano" and "mini" tiers, from $0.10–0.15 input) up to the GPT-5 family's reasoning flagships, which sit in the **$1.25–5 input and ~$10–30 output** range per million tokens depending on the variant. The big upside: a huge ecosystem, impeccable docs, and SDKs for everything. The downside: it's rarely the cheapest for a given task, and to get the most from the top models you pay top price.
Anthropic (Claude)
The strong house for code, long-horizon agents, and tasks where reliability is on the line. Its range has three clear tiers: Haiku (the fast, cheap one, around ~$1 input / ~$5 output), Sonnet (the balanced one, ~$3 / ~$15) and Opus (the flagship, ~$5 / ~$25). All with a huge context window (up to 1M tokens on the current models) with no long-context surcharge. If your product lives on generating or reviewing code, or on agents that run tasks for minutes, Claude tends to punch above its price.
Note
The Claude figures we give are the per-tier ranges (Haiku / Sonnet / Opus) as of mid-2026; Anthropic publishes the exact per-model numbers on its pricing page. Prompt caching and batch mode apply the same as everywhere else and cut real production cost substantially.
Google Gemini
The one that best combines price and capability in the mid band. Its Flash models are dirt cheap for what they deliver (from ~$0.10–0.30 input in the lightweight versions, up to $1.50 in the newest Flash), and the Pro models go toe to toe with the big ones on quality ($2–4 input / ~$12 output, with a price jump past 200K context). Gemini shines on multimodality (image, audio, video) and has a generous free tier via Google AI Studio to test before paying.
Open source via Groq, Together AI and Fireworks
This is where the cheap money is. Powerful open models —DeepSeek, Llama, Qwen, Kimi and friends— served by providers that just supply the GPUs. Prices run from ~$0.05 to ~$0.90 per million tokens on most models, a fraction of what the proprietary ones cost. Each provider has its angle:
- Groq: speed. Its custom chips (LPUs) serve 500+ tokens per second. If you need instant responses, it's the benchmark.
- Together AI and Fireworks: their own infrastructure (H100/H200/B200), no middleman, very competitive per-token pricing, and a wide catalog of open models.
The cost: the average quality of open source still trails the best GPT-5 and Opus on the most demanding work, though the gap closes every quarter.
Comparison table
| Provider / tier | Input ($/MTok) | Output ($/MTok) | Wins at | When to use it |
|---|---|---|---|---|
| OpenAI · mini/nano | ~0.10–0.15 | ~0.40–0.60 | Balance + ecosystem | Light tasks at volume with a mature SDK |
| OpenAI · GPT-5 (top) | ~1.25–5 | ~10–30 | Quality and reasoning | The hardest work, if you're already in their stack |
| Anthropic · Haiku | ~1 | ~5 | Fast and cheap among the big ones | Volume with good quality and long context |
| Anthropic · Sonnet | ~3 | ~15 | Balanced code and agents | The workhorse for product |
| Anthropic · Opus | ~5 | ~25 | Top code and agents | Critical long-horizon tasks |
| Google · Gemini Flash | ~0.10–1.50 | ~0.40–9 | Price/quality and multimodal | Mid band, image/audio/video |
| Google · Gemini Pro | ~2–4 | ~12 | Near-top quality, cheap | High quality without paying premium price |
| Open source (Groq/Together/Fireworks) | ~0.05–0.90 | ~0.10–1 | Price (and speed on Groq) | Volume, minimal cost, independence |
Which to choose for your case
The table is fine, but the decision lands with concrete scenarios.
You need maximum quality and money is secondary. Top-tier GPT-5 or Claude Opus. For code and agents that run long tasks, Claude tends to have the edge; for general knowledge and pure reasoning, GPT-5. Gemini Pro is the third serious option and often cheaper.
You need reasonable quality at the lowest possible cost. Open source models via Together or Fireworks, or the big providers' "mini/flash" tiers. This is 80% of real tasks: classify, summarize, extract, answer questions with context. Don't pay Opus prices to label emails.
You need speed above everything. Groq. When your AI answers a user in real time and every millisecond counts, almost nobody matches its 500+ tokens/s — and at open source prices on top.
You're prototyping and don't know yet which model you want. Don't commit to any one yet: use OpenRouter (next section) and switch models by changing a string.
Tip
A pattern that saves a lot in production: routing by difficulty. Send the easy tasks to a cheap model and only escalate to the expensive one when the task demands it. Many teams use a small model as a filter and reserve the big one for what genuinely needs it. Done right, it slices the bill without a noticeable quality drop.
OpenRouter: the shortcut to commit to no one
Juggling five accounts, five keys and five bills to compare models is a pain. OpenRouter solves it: a single endpoint —compatible with the OpenAI API, so migrating is almost just changing the base URL— and a single key to talk to hundreds of models from every provider. One bill.
What it gives you:
- Frictionless testing. You go from GPT-5 to Claude to an open Llama by changing the model name in the request. Zero new code.
- Automatic routing. It can send your request to the cheapest or fastest provider serving that model, and fail over if one goes down.
- One bill for everything. Instead of reconciling spend across five dashboards.
It charges a small margin over the provider's price, so for a high-volume production app you may want to go straight to the cheapest provider. But for prototyping, comparing and not getting locked in to a single house, it more than pays off.
from openai import OpenAI
client = OpenAI(
base_url="https://openrouter.ai/api/v1",
api_key="YOUR_OPENROUTER_KEY",
)
response = client.chat.completions.create(
# Change this string to switch model and provider:
model="anthropic/claude-sonnet-4-6",
messages=[{"role": "user", "content": "Summarize this in 3 points: ..."}],
)
print(response.choices[0].message.content)Who each one is for
OpenAI if you value the most mature ecosystem, the best documentation, and not wanting to overthink it: it's the safe pick, even if it's rarely the cheapest.
Anthropic (Claude) if your product lives on code, on agents that run long tasks, or on reliability in critical tasks, and the huge context window helps you.
Google Gemini if you want high quality without paying premium price, need multimodality (image, audio, video) or a generous free tier to get started.
Open source (Groq/Together/Fireworks) if you process volume, cost per token is your main metric, or you want independence from the big ones —and, in Groq's case, raw speed.
OpenRouter if you're starting out, comparing, or simply don't want to tie yourself to one provider while the market keeps moving.
The uncomfortable truth is that there is no best API: there's the best combination for your case, and it's almost always more than one at a time —a cheap model for the bulk, an expensive one for the hard stuff, and an aggregator so you're not chained down—. Start by understanding your mix of input and output, test two or three options through OpenRouter, and let the real bill, not the brochure, tell you which one stays.