Every LLM API price comparison starts the same way: a table of dollars per million tokens, sorted ascending, decision made at the top row. That table is where cost analysis should start — and where most of it wrongly ends. Our free LLM price comparison tool puts the models side by side; this guide covers the part the table can't show you: how your workload's shape decides which model is actually cheapest, and why the bargain row sometimes sends the biggest invoice.
Every model has an input rate and an output rate, and output usually runs several times higher. So the first question isn't "which model is cheap?" — it's "what does my workload read versus write?" A summarizer ingesting 50-page documents and emitting three paragraphs lives on the input meter; the model with the cheapest input rate wins even if its output rate is mediocre. A copywriting engine is the mirror image. Compute a blended rate from your real input:output ratio — measured with the token counter, not guessed — and the ranking in the pricing table will often reshuffle before you've considered anything else.
Two mechanisms routinely move costs more than switching providers. Prompt caching knocks roughly 90% off tokens you re-send — which, in agent and chat workloads that replay the whole history every turn, is most of the bill. Batch processing takes about half off everything, in exchange for results in hours instead of seconds. Now stack them against workload shape: a model at twice the sticker price with strong caching can beat the "cheap" model on a long-running agent, because the expensive model is discounting 80% of the traffic while the cheap one meters every replayed token at full rate. A comparison that ignores discount mechanics isn't comparing prices — it's comparing brochures.
Here's the metric that actually matters: cost per completed task. A budget model that needs two retries, a longer prompt full of guardrails, and an occasional human cleanup pass is not cheaper than a stronger model that nails it once — it just books its costs in places the pricing table doesn't show. The honest comparison is empirical: run 20 representative tasks through each candidate, count total tokens consumed (including the retries), divide by tasks completed correctly. Weak models also tend to need more scaffolding — more examples in the prompt, more validation steps, more correction turns — and every gram of that scaffolding is metered input you pay for on every call, forever. Cheap per token and expensive per outcome is the most common pricing trap in production AI.
A complete price comparison includes the row where the meter reads zero: running open-weight models on hardware you own. The trade is real — you pay upfront for the GPU, you own the ops, and the biggest open models still trail the frontier APIs on the hardest tasks. But for the bulk lane — classification, extraction, drafts, embeddings, anything you do a million times — local inference turns a variable cost into a fixed one. We run this playbook ourselves: our own 35B-parameter model serves at a measured 220–256 tokens/second on two RTX 5090s in the founder's workstation, at zero marginal cost per token — which changes what "cheap" means for every batch job we run. The self-hosting cost math and the cloud-vs-local GPU comparison walk the break-even arithmetic; the short version is that utilization decides it — a busy GPU pays for itself, an idle one is furniture.
Ten minutes, four steps. One: measure your workload — tokens in, tokens out, calls per day, turns per conversation. Two: shortlist models that clear your quality bar on real samples (quality first; a wrong answer at any price is overpriced). Three: apply the real rates in the comparison tool, including caching and batch discounts your traffic qualifies for. Four: sanity-check speed against your latency budget with the inference speed guide — the cheapest adequate model that's too slow for your UX isn't adequate. Then re-run the numbers quarterly: prices in this market move fast, and yesterday's premium tier is regularly today's mid-market.
Which LLM API is cheapest? For your workload, the one with the lowest cost per completed task — which depends on your input:output ratio, caching hit rate, batch eligibility, and retry rate. The generic answer ("the smallest model on the list") is only right when the task is easy enough that quality differences don't bite.
Are open-weight models free? The weights are; the electricity, hardware, and your time are not. Self-hosting swaps a per-token fee for fixed costs — a win at high utilization, a loss for spiky low-volume traffic. Do the break-even math before buying anything.
How often do API prices change? Often enough that any static comparison rots in months. Price cuts, new tiers, and new models land constantly — re-price your stack quarterly and after any major model release.
The per-token table is the beginning of a price comparison, not the verdict. Measure your shape, apply the discounts, price the task, and include the own-your-hardware row. The cheapest model on the sticker is frequently the most expensive thing in your stack — and the arithmetic that proves it takes less time than reading this post did.
Price the workload, not the hype. Run your numbers in the free LLM price comparison tool, then join early access for QADIR OS — the sovereign agentic operating system from ABUZ8. No card required.