$0.14. Per million tokens. That’s what production AI costs right now. Not a typo. Not a trial tier.
But you’re probably paying $30. Per million. For GPT-5.5. That’s three cents per response. A thousand responses a day: $30. A month: $900. Before you even launch. Before you notice the reasoning tokens silently eating another 2–5x off your bill.
Stop. You don’t have to live like this.
In 2026, models exist that cost 1/40th of OpenAI’s price. Same quality for 85% of real-world tasks. The gap isn’t in capability —it’s in awareness.
This article maps the entire landscape: the 15 cheapest models ranked with real quality benchmarks, the hidden fees that turn “cheap” APIs into expensive mistakes, free tiers you can actually build production features on, and a zero-to-scale path that doesn’t require changing a single line of code.
The Cheapest LLM APIs in 2026: Ranked (as of July 2026)
Cheap means nothing without a quality floor. Every model in this ranking has a verified use case where it delivers acceptable quality. Models that are cheap but unusable aren’t listed.
Ultra-Budget Tier ($0.01–0.15 per million tokens)
These are the cheapest models that still produce coherent, useful output. They handle classification, extraction, simple Q&A, and boilerplate generation reliably. They are not for complex reasoning.
| Model | Input $/M | Output $/M | Context | Quality Floor | Best Use Case |
|---|---|---|---|---|---|
| GLM-4.7 Flash | Free | Free | 128K | ~85% of GPT-4o-mini | Prototyping, simple chatbots |
| GLM-4-9B | $0.01 | $0.01 | 32K | Basic text tasks | Ultra-low-cost classification |
| Qwen3-8B | $0.01 | $0.01 | 32K | Basic text + code | Minimal-cost extraction |
| GPT-4.1 Nano | $0.10 | $0.40 | 1M | Solid reasoning | Long-context budget tasks |
| Llama 4 Scout | $0.11 | $0.34 | 10M | Good for its tier | Ultra-long context (10M) |
| DeepSeek V4 Flash | $0.14 | $0.28 | 1M | 92% HumanEval | Text gen, classification, simple coding |
DeepSeek V4 Flash sets the benchmark for this tier. At 92% HumanEval —matching GPT-4o’s coding benchmark within 0.5 points —it’s not just “good for the price.” It’s good, period. At $0.14 input and $0.28 output (DeepSeek’s official pricing), you can process 3.5 million output tokens for $1. That’s roughly 2,600 pages of generated text. Try that with GPT-5.5: the same output would cost $105.
GLM-4.7 Flash deserves a special mention: it’s completely free with 128K context and an OpenAI-compatible API. No credit card, no trial expiration, no usage cap (within fair-use limits). For prototyping, personal projects, and learning, there is no reason to pay for anything else. The catch: documentation is Chinese-first, the API can be unstable during Chinese business hours, and the data-use policy is unclear. Don’t send sensitive data through it.
Budget Tier ($0.15–0.50 per million tokens)
These models deliver near-frontier quality for specific tasks at prices that make “just use GPT-5.5 for everything” a $500/month mistake.
| Model | Input $/M | Output $/M | SWE-bench | Best For |
|---|---|---|---|---|
| DeepSeek V4 Pro | $0.435 | $0.87 | ~85% | Primary coding model, general reasoning |
| Qwen3-32B | $0.18 | $0.28 | ~75% | Multilingual (Japanese, Korean, Arabic) |
| GPT-5.4 Nano | $0.20 | $1.25 | — | OpenAI ecosystem, moderate quality |
| Llama 3.3 70B | $0.10 | $0.40 | — | Self-hosting, privacy-sensitive |
DeepSeek V4 Pro is the best value coding model in existence. At $0.87/M output and ~85% SWE-bench, it costs 1/29th what Claude Opus 4.8 costs for coding quality that’s indistinguishable for ~85% of real tasks. The gap shows up in complex architectural decisions and corner-case debugging —not in “write me a function that parses CSV files.”
Qwen3-32B at $0.18/$0.28 is the best value for multilingual applications. It outperforms GPT-5.5 on C-Eval (Chinese), Japanese, Korean, and Arabic benchmarks. If your user base is primarily non-English, this is likely your best model regardless of price.
Value Tier ($0.50–1.50 per million tokens)
These are near-frontier models that have broken the “80%+ SWE-bench club” —a capability threshold that was exclusive to $15–30/M models 18 months ago.
| Model | Input $/M | Output $/M | SWE-bench | Context |
|---|---|---|---|---|
| MiniMax M3 | $0.60 | $2.40 | 80.5% | 1M |
| Qwen3.7 Max | $1.25 | $3.75 | 80.4% | 1M |
| Kimi K2.6 | $0.95 | $4.00 | 80.2% | 256K |
| GLM-5 | $1.00 | $3.20 | — | 200K |
| Mistral Large 3 | $0.50 | $1.50 | — | 262K |
MiniMax M3 is the cheapest model in the 80%+ SWE-bench club —$2.40/M output —and delivers the best coding value per dollar of any model (0.034 SWE-bench points per dollar; GPT-5.5 delivers 0.003). For teams that need guaranteed coding quality but can’t justify $25–50/M output, this is the model.
Hidden Costs That Inflate Your Bill
Sticker prices lie. Here’s what the pricing page doesn’t show you.
Reasoning tokens are invisible and expensive. When GPT-5.5 or Claude Opus “thinks” before responding, those internal chain-of-thought tokens are billed at the output rate. You don’t see them in the response —but you pay for them. A request that produces 500 visible output tokens may have consumed 1,500 reasoning tokens behind the scenes. Your effective $30/M becomes $120/M for that request. OpenAI recently added a reasoning_tokens field to track this; monitor it.
Prompt length creep is silent. Your “simple classification” prompt starts at 200 tokens with two examples. Six months later, you’ve added five more examples, a detailed output format specification, and a preamble about “you are a helpful assistant.” The prompt is now 2,500 tokens. You’re paying 12.5x more per request —and you didn’t notice because the cost increase was gradual. Audit your prompt lengths quarterly.
The “free tier trap” has teeth. Google’s free Gemini tier may use your data for training. DeepSeek’s privacy policy is ambiguous about data usage. Many free tiers serve lower-quantization versions of models (noticeably worse quality than paid). And free tier rate limits (15–30 RPM) will break your production app at the worst possible moment. Free tiers are for prototyping. The moment you have real users, switch to paid.
Rate-limit waste adds 15–20% overhead. If your client retries on 429 with a fixed 1-second interval, you’re creating a thundering herd that guarantees more 429s. Exponential backoff with jitter is the fix —tenacity in Python, llm-retry-kit in Node.js. But the bigger fix is predictive throttling: read the x-ratelimit-remaining-* headers and slow down before you hit the limit. For a complete rate-limit implementation, see our production rate-limit handling guide.
For the full 12-strategy cost optimization playbook with before/after savings data, read our guide to reducing API spend.
Free LLM APIs: What You Can Actually Build With $0
There are more genuinely free, permanently available LLM APIs in 2026 than at any point in the industry’s history. Here’s what’s actually usable —and what each can handle.
| Provider | Model | Limit | Best For | Data Training? |
|---|---|---|---|---|
| Google AI Studio | Gemini 2.5 Flash | 1,500 req/day | Prototyping, long-context, multimodal | Yes (free tier) |
| Groq | Llama 3.3 70B, Qwen3 32B | 30 RPM / 14,400 RPD | Real-time chat (300–500 tok/s) | No |
| Cerebras | Llama 3.3 70B, Qwen3 235B | 30 RPM / 1M tok/day | Batch processing (2,500+ tok/s) | No |
| OpenRouter | 35+ free models | 20 RPM / 200 RPD | Model experimentation | Depends on model |
| Z.AI (Zhipu) | GLM-4.7 Flash | ~1,000 RPD | Free production for simple tasks | Unclear |
| GitHub Models | GPT-4o, Claude 3.5 Sonnet, 45+ | 10–15 RPM / 50–150 RPD | Frontier model access for free | No |
GitHub Models is retiring on July 30, 2026. If you’re using it, migrate before then. OpenRouter’s free tier or a low-cost aggregation platform are the most straightforward alternatives with comparable model access.
What you can actually build: A customer support chatbot handling ~200 conversations/day (Gemini Flash free tier). A code review bot for a small team’s PRs (Groq free tier, Llama 3.3 70B). A personal writing assistant (Cerebras free tier). An automated data extraction pipeline for ~500 documents/day (GLM-4.7 Flash).
What you can’t build: Anything with an SLA. Anything processing sensitive user data where training opt-out is required. Anything that spikes above 50 concurrent requests. Free tiers are excellent for validation —“does anyone actually want this product?” They’re not for production.
The $0-to-paid bridge. The friction of switching from free prototyping to paid production usually involves creating new accounts, adding payment methods, and changing API endpoints. Aggregation platforms remove this friction: you prototype on free-tier models, add $5–20 to your prepaid balance when you’re ready, and keep the same endpoint, same SDK code, and same model names. Zero migration. This is the fastest path from “I have an idea” to “I have a production app,” and it costs less than lunch to start.
When Cheap APIs Fail: Quality Boundaries
Cheap models have real limits. Knowing where they fail is more important than knowing where they succeed.
Tasks where cheap models struggle: Complex multi-step reasoning that requires holding 3+ constraints simultaneously (e.g., “analyze this contract, identify clauses that conflict with California law, and draft alternative language”). Nuanced creative writing with a specific voice or tone. Code review that requires understanding the architectural implications of a change (not just “is this line correct”).
The smart escalation pattern. Route 80% of requests to a cheap model (DeepSeek V4 Flash, $0.14/$0.28). For the 15% that need more capability, escalate to a mid-tier model (DeepSeek V4 Pro, $0.44/$0.87, or Claude Sonnet, $3/$15). For the 5% that need maximum depth, escalate to a frontier model (Claude Opus, $5/$25, or GPT-5.5, $5/$30). Weighted average cost: roughly $0.55/M output —98% cheaper than all-frontier. Quality: identical for end users who can’t tell which model handled their request. For the complete routing implementation with code, see our custom routing setup.
What makes cheap models practical at scale. A model that costs $0.14/M tokens on paper still requires an account, a payment method, and a rate-limit dashboard to use. Stack five such models and you are back to managing five provider relationships —the per-provider overhead eats the savings. Aggregation platforms solve this by collapsing access into a single prepaid balance: deposit $10 once, route every model in this article through the same endpoint. Volume pooling across thousands of users means the effective per-token rate lands below official retail, typically 10–20%. The practical result: you can use DeepSeek Flash at effectively $0.10/M input alongside Claude Opus at $22/M output, from one account, with one invoice. That is when cheap becomes actually cheap.
FAQ
Is DeepSeek V4 Flash really as good as GPT-4o?
On coding benchmarks: 92% HumanEval vs. 92.5% (GPT-4o). On general reasoning: 85.5% MMLU vs. 88.7% (GPT-4o). For 90% of text tasks —classification, extraction, summarization, simple coding —yes, it’s functionally equivalent. For vision, multimodal, and complex multi-step reasoning: no. The gap is measurable but irrelevant for the majority of production workloads. See our full four-way comparison for detailed benchmark data.
What’s the absolute cheapest LLM API with no credit card?
GLM-4.7 Flash from Zhipu AI —completely free, 128K context, OpenAI-compatible endpoint. Google Gemini Flash —free tier, 1,500 requests/day, no credit card. For paid: DeepSeek V4 Flash at $0.14/$0.28 per million tokens, accessible through aggregation platforms that accept a range of payment methods.
Are Chinese AI APIs reliable for production?
DeepSeek and Qwen maintain 99.5%+ uptime on their paid tiers. The main friction points for international developers are Chinese-language documentation, Chinese phone number requirements for direct sign-up, and limited English-language community support. Aggregation platforms solve all three: English docs, no phone number requirement, and community support in your language. Once connected, the API reliability is comparable to Western providers.
Do cheap APIs train on my data?
It depends. Google’s free tier may use data for training (they’re explicit about this). DeepSeek’s policy is ambiguous —the terms don’t clearly state whether API data is used for training. Zhipu (GLM) has a similarly unclear policy. Paid tiers generally offer training opt-out. Enterprise tiers have contractual guarantees. If you’re handling sensitive data, use a provider with clear data-use terms or an aggregation platform that provides contractual data-processing agreements.
How do I start with $0 and scale to production?
Start with free tiers (Google AI Studio, Groq, GLM-4.7 Flash) to build and validate. When you need more throughput, add $5 to an aggregation platform prepaid balance. Your code doesn’t change —same endpoint, same SDK, same model names. You just get higher rate limits, paid-tier quality (unquantized models), and access to premium models when you need them. The transition from “free prototype” to “paid production” takes 60 seconds and requires zero code changes. Our getting started guide walks through the full setup.
Here is your concrete next step. Audit your last 1,000 API calls. Count how many went to models priced above $5 per million output tokens. Take every classification, extraction, and simple Q&A call in that bucket and reroute it to DeepSeek V4 Flash at $0.28 per million output. Take every coding and reasoning call and reroute it to DeepSeek V4 Pro at $0.87. Leave frontier models on standby for the 5% of requests that genuinely need them —complex debugging, legal analysis, multi-step agents. Do the reroute this week. Your bill drops 80 to 90 percent, your users will not notice the difference, and you will not need to read another pricing article.
The routing change takes ten minutes. If you want to make it one —same endpoint for every model in the pricing table, no per-provider sign-up, a single prepaid balance —TokSpan’s aggregation endpoint lets you switch between DeepSeek V4 Flash and Claude Opus by changing a model string. The free tier covers prototyping. Paid tiers start at $5.