The cheapest LLM APIs in 2026 are almost all small, fast models priced per million tokens: expect budget tiers in the range of a few cents to roughly $0.50 per million input tokens, with output typically 2–5x higher. Exact leaderboards shift monthly, so the practical answer is to compare on a blended cost basis (your real input/output mix) rather than sticker price. Below, "cheap" is treated as a moving target defined by your workload, not a single winner.
Why Price Per Million Tokens Is the Wrong-But-Useful Metric
Per-million-token pricing (the list price for processing one million tokens, where a token is a chunk of text roughly 3–4 characters in English) is the industry's standard unit because it is simple to publish and compare. It is "wrong" because almost nobody pays the list price for a real workload: your bill depends on the ratio of input to output tokens, how much you reuse prompts, whether you batch requests, and which model tier you route each request to. Two APIs with identical headline prices can differ by several times in actual monthly cost.
It is still useful because it is the only number every provider publishes in the same unit, which makes it a decent first-pass filter. Treat it as a starting index, then adjust. A reasoned way to do that is to compute a blended price from your own mix:
blended_price_per_mtok = (input_share * input_price) + (output_share * output_price)
If your workload is 80% input and 20% output, an API priced at $0.10 input / $0.40 output costs 0.8*0.10 + 0.2*0.40 = $0.16 per million blended tokens, not $0.10. Run that arithmetic before declaring anything "cheapest."
The Cheapest LLM APIs of 2026 Compared
Rather than a fixed table that will be stale by the time you read it, compare by tier. Providers generally cluster into three price bands, and within each band the spread is smaller than the spread between bands. As an estimate based on typical 2025–2026 market structure, not a quoted price list:
- Ultra-budget small models: roughly $0.02–$0.15 per million input tokens, output roughly $0.05–$0.60. These are distilled or "mini" models suited to classification, extraction, routing, and short answers.
- Mid-tier general models: roughly $0.15–$1.00 input, $0.60–$4.00 output. The default choice for most production chat and RAG (retrieval-augmented generation, where you paste retrieved documents into the prompt).
- Frontier models: several dollars per million input and tens of dollars per million output. Rarely the cheapest per token, but sometimes cheapest per completed task because they need fewer retries and shorter prompts.
The trap is comparing across bands. A frontier model that solves a task in one 500-token call can beat a budget model that needs three 2,000-token attempts. Estimate cost per successful task, not per token:
cost_per_task = attempts * (input_tokens * input_price + output_tokens * output_price) / 1e6
Also check the non-token levers, since they often matter more than the headline rate: free tiers and rate limits, batch APIs (often discounted in exchange for delayed processing), and whether the provider charges for cached input at a reduced rate. When you build your comparison sheet, record input price, output price, cache-read price, batch discount, and context limit per model — those five columns capture nearly all of the real cost difference.
Input vs Output Pricing: Where Your Budget Actually Goes
Every major API charges output tokens at a higher rate than input tokens, typically two to five times more. The reason is mechanical: input tokens are processed in parallel during the prefill phase, where the model reads the whole prompt at once, while output tokens are generated one at a time in the decode phase, each requiring a full forward pass through the network. Generation is sequential and memory-bandwidth-bound, so providers price it higher.
The practical consequence: your bill is dominated by how much the model writes, not how much you send it. A chat assistant that reads a long document but replies briefly may spend most of its budget on input; a code generator that emits long files pays mostly for output.
Worked example. Assume a cheap model priced at $0.10 per million input tokens and $0.40 per million output tokens (a plausible 2026 budget-tier ratio of 1:4; treat as an estimate). Suppose you run 2,000 requests per day, each with a 1,500-token prompt and a 400-token response.
Input: 2,000 × 1,500 = 3,000,000 tokens/day → 3 × $0.10 = $0.30/day
Output: 2,000 × 400 = 800,000 tokens/day → 0.8 × $0.40 = $0.32/day
Total: ~$0.62/day ≈ $18.60/month
Output is 21% of token volume but 52% of cost. Halving response length saves roughly $9/month; halving prompt length saves about the same—so both levers matter, but output is the pricier one per token.
How Tokenization and KV-Cache Shape Real Costs
A token is the unit models read and bill: roughly ¾ of a word in English, less for code, numbers, or non-Latin scripts, which tokenize less efficiently and cost more per visible character. Tokenization is the process of splitting text into these subword units; a tokenizer trained mostly on English fragments other languages into more pieces, so the same sentence can cost two to three times more in, say, Japanese than in English.
The KV-cache (key-value cache) stores intermediate attention states for tokens already processed so the model doesn't recompute them. Providers use it in two ways: within a single request, cached prompt tokens cost full price but generation is faster; across requests, prompt caching lets you resend a long fixed prefix (system prompt, reference document) at a steep discount—commonly 50–90% off input price on cache hits, depending on provider and cache lifetime. This is the single biggest lever for RAG (retrieval-augmented generation) and agent workloads with stable context.
Checklist before estimating cost:
- Measure real token counts with the provider's tokenizer, not word counts.
- Split your estimate into cached input, uncached input, and output, each at its own rate.
- Test non-English and code inputs separately—they inflate token counts.
- Check cache hit requirements (minimum prefix length, TTL) before assuming discounts.
Estimation formula:
monthly = requests × [ (cached_in × p_cache) + (uncached_in × p_in) + (out × p_out) ] / 1,000,000
## Frequently Asked Questions
### What is the cheapest LLM API per million tokens in 2026?
There is no single cheapest API, because the answer depends on which model tier you compare and whether you count input tokens, output tokens, or both. Small, distilled models (often marketed as "mini," "flash," or "lite" variants) sit at the low end and can cost a small fraction of a flagship model's per-token price, sometimes under a dollar per million input tokens on promotional or batch tiers. A practical answer: for high-volume, simple tasks, budget roughly USD 0.1–1 per million input tokens and 0.4–4 per million output tokens for budget-tier models, and expect flagship models to run 10–50x higher — treat these as reasoned estimates, not quotes, and always check current provider pricing pages since they change often.
### Why do output tokens cost more than input tokens?
Generating text is sequential: the model produces one token at a time, and each new token requires a full forward pass through the network, so cost scales with output length and cannot be parallelized the way reading a prompt can. Input tokens, by contrast, are processed in a single batched pass, which is far more efficient on modern GPUs. Providers also factor in memory bandwidth and inference time, which dominate during generation, so output prices are typically 2–5x input prices across most vendors.
### How does tokenization affect the price I pay per word?
Tokenization splits text into subword units, and billing counts tokens, not words, so the word-to-token ratio determines your real cost per word. English averages roughly 0.75 words per token (about 1.3 tokens per word), but code, numbers, punctuation-heavy text, and non-English languages tokenize less efficiently and can push the ratio to 2–4 tokens per word or more. Before committing, run a sample of your actual traffic through the provider's tokenizer (most publish one) and compute:
cost_per_word = tokens_per_word x price_per_token
### Can KV-cache and prompt caching lower my API bill?
Yes. A KV-cache (key-value cache) stores the intermediate attention states for tokens already processed, so the model doesn't recompute them for every new output token; providers use this internally to make generation feasible, and some expose prompt caching that bills repeated prompt prefixes at a discounted rate. If your application reuses long system prompts, documents, or conversation history, caching those prefixes can cut input costs substantially — often by 50–90% on the cached portion, depending on the provider's cache pricing. The catch: caches expire after minutes to hours, so savings depend on request patterns that repeatedly hit the same prefix.
### How do I estimate my monthly LLM API cost before committing?
Build a simple model from three inputs: average input tokens per request, average output tokens per request, and requests per month, then apply the provider's per-million-token prices separately to input and output:
monthly_cost = (requests x input_tokens / 1_000_000 x input_price) + (requests x output_tokens / 1_000_000 x output_price)
Measure token counts on a sample of real prompts and responses rather than guessing, add a 20–30% buffer for retries and longer-than-average responses, and run the same numbers across two or three providers to compare. For variable workloads, also check whether batch discounts or cached-prefix pricing apply to your traffic before finalizing a budget.