If you are shopping for the cheapest way to run a given model, the sticker price on a provider's page is only half the story. What you pay depends on the model tier, the fees the gateway stacks on top, and whether you cache repeated calls. This guide lays out the numbers so you can compare like for like.
All prices below are per million tokens, split into input and output, and reflect a 2026-07-22 snapshot pulled from live catalogs. Prices move, so treat this as a dated reference and check the live model pricing before you commit a budget.
LLM API prices by tier (per 1M tokens)
Costs cluster into three tiers by capability. Matching the tier to the task is the single biggest lever on your bill.
| Tier | Typical use | Example models | Input | Output |
|---|---|---|---|---|
| Nano / Flash | Classification, extraction, filtering | gpt-5-nano:flex, Gemini Flash | $0.025 to $0.30 | $0.20 to $0.40 |
| Mid | Drafting, summarization, code | deepseek-chat, gpt-5-mini:flex | $0.125 to $3 | $1 to $3 |
| Frontier | Complex reasoning, final review | GPT-5, Claude Opus, o3 | $1 to $15 | $4 to $20 |
The math that follows from this table: sending everything to a frontier model when 70% of your calls are classification is how bills balloon. Routing that 70% to a nano tier model and reserving frontier models for the 10% that need them cuts average cost per query by 60 to 80 percent. We break the full pattern down in AI agent cost optimization.
Where a gateway is cheaper than direct or than another gateway
Two gateways can charge different amounts for the exact same model. Here are the OpenAI flex-tier models and deepseek-chat where Requesty runs at roughly half of OpenRouter, because Requesty passes through a lower provider tier (2026-07-22 snapshot, per 1M tokens):
| Model | Requesty (in / out) | OpenRouter (in / out) | Requesty saving |
|---|---|---|---|
| gpt-5:flex | $0.625 / $5 | $1.25 / $10 | 50% |
| gpt-5-mini:flex | $0.125 / $1 | $0.25 / $2 | 50% |
| gpt-5-nano:flex | $0.025 / $0.20 | $0.05 / $0.40 | 50% |
| o3:flex | $1 / $4 | $2 / $8 | 50% |
| o4-mini:flex | $0.55 / $2.20 | $1.10 / $4.40 | 50% |
| deepseek-chat | $0.14 / $0.28 | $0.20 / $0.80 | up to 65% on output |
On most models the two are identical, and the difference comes from what the gateway charges on top rather than the token price itself. Which brings us to fees.
The fees stacked on top of token price
Comparing model prices alone hides the real bill. Each gateway adds a different structure:
| Gateway | On-top cost | Seat / subscription | BYOK |
|---|---|---|---|
| Requesty | Flat 5% markup | None | Included |
| OpenRouter | Fee on credit purchase, plus a per-request BYOK fee after a free tier | None | Charged after free tier |
| Portkey | Per-log pricing above the free tier | Production plan subscription plus overage | Varies |
| Helicone | Usage-based on top of seats | Pro and Team seat tiers | Varies |
| LiteLLM | None on tokens, you run the infra | Free open-source, paid support tiers | You manage keys |
The takeaway: OpenRouter markets pass-through inference "without markup," but there is a fee when you purchase credits and a per-request fee on bring your own key usage after a free allotment. Requesty's 5% is flat and BYOK is included, so what you see is what you pay. For a full head to head, see Requesty vs OpenRouter.
For teams, the seat question dominates. A per-seat or per-log platform bills you more as your team grows even if token usage is flat. A flat token markup does not. If you are a multi-developer team, model the total cost including seats, not just the per-token rate.
Two more levers that beat picking a cheap model
- Caching. Prompt caching stores repeated prefixes (system prompts, tool definitions, long context) so the provider does not reprocess them. This cuts repeated-call cost by 40 to 90 percent and often makes a gateway net cheaper than direct calls. See how prompt caching cuts costs.
- Routing by cost and latency. Instead of hard-coding one model, route each request to the cheapest capable model at that moment. The mechanics are in how to route LLM requests by cost and latency.
Compare, then route
The cheapest LLM API is not a single model, it is the cheapest capable model for each request, minus the fees around it, minus what caching saves. A gateway that charges a flat 5% with no seats, includes BYOK, and routes across 596 models lets you capture all three at once.
Start with the live model catalog and prices, then wire up routing so every request lands on the cheapest path. Sign up at app.requesty.ai to get an API key and point your OpenAI-compatible client at https://router.requesty.ai/v1.
Frequently asked questions
- What is the cheapest LLM API in 2026?
- It depends on the task. For high-volume classification and extraction, nano and flash tier models run $0.025 to $0.30 per million input tokens. For drafting and code, mid-tier models sit around $0.14 to $3. Frontier reasoning models run $1 to $15. The cheapest option per request is whichever capable model has the lowest price at that moment, which is why routing beats picking one model for everything.
- Is it cheaper to call an LLM API directly or through a gateway?
- It varies by model and by gateway. On many models the price is identical whether you go direct or through a gateway, and the gateway adds routing, caching, and failover on top. On some models a gateway is cheaper: Requesty prices several OpenAI flex-tier models and deepseek-chat at roughly half of OpenRouter, because the gateway passes through a lower provider tier. Caching also cuts repeated-call cost by 40 to 90 percent, which often makes the gateway net cheaper than direct.
- How does Requesty pricing work?
- Requesty charges a flat 5% markup on token cost. There is no subscription, no seat fee, and no minimum spend. Routing, caching, and an EU data residency option are included on every plan, and bring your own key (BYOK) is included. You pay for tokens plus 5%, and nothing else.
- Why do the same models cost different amounts on different gateways?
- Two reasons. First, gateways sometimes route to different provider tiers (standard, flex, or priority), which have different prices for the same model. Second, gateways charge differently on top: a flat markup, a credit-purchase fee, a per-log fee, or a per-seat subscription. Comparing the sticker price of the model alone misses the fees stacked around it.
- JUN '26
AI Agent Cost Optimization: How to Cut LLM Spend by 80% with Routing
AI agents generate 10x to 100x more tokens than chatbots. Without optimization, inference costs dominate your cloud bill. This guide covers the four techniques that cut agent spend by 60 to 80 percent: model routing, prompt caching, context management, and budget caps.
- MAY '26
How to route LLM requests by cost and latency
A practical guide to routing LLM requests across providers based on cost and latency. Covers when to use each strategy, how to combine them, and how Requesty handles it under the hood.
- JUL '25
How LLM Gateways Slash AI Spend by up to 80%
- MAR '25
Maximize AI Efficiency: How Prompt Caching Cuts Costs by Up to a Staggering 90%