Which Frontier Model Is Actually Cheapest for Your Workload?

"What's the cheapest LLM?" is the wrong question. The right one is "what's the cheapest model for this workload?" — because input and output tokens are priced separately, often at a 3–8× ratio, and every model has a different split. A model that looks cheap on a pricing chart can be the expensive choice for your specific traffic, and vice versa.

Why the ranking flips

Every model publishes two rates: an input (prompt) price and an output (completion) price, both per million tokens. The ratio between them varies a lot — some frontier models price output at roughly 5× input, others closer to 3×. That ratio, combined with your input-to-output token ratio, determines your real cost:

effective cost ≈ (input tokens × input rate) + (output tokens × output rate)

Two models can have very different rankings depending on which side of that equation dominates your traffic. Live current pricing for every tracked model is on the pricing page — the framework below tells you which numbers on that page matter most for your case.

Three workload shapes, three different answers

1. Long-context RAG / document Q&A (input-heavy)

You're stuffing 5,000–20,000 tokens of retrieved context into every call and getting back a few hundred tokens of answer. Input volume dwarfs output volume — often 10:1 or higher. Here, the input rate is what matters, and a model with an unusually low input price (even if its output price is middling) will often win. This is also exactly the workload where prompt caching pays off hardest, since the retrieved context or knowledge base excerpt is frequently reused across queries.

2. Short-prompt classification / extraction (balanced-to-input-heavy)

A short instruction plus a chunk of text in, a short structured label out. Volume is usually moderate on both sides, and — importantly — this task rarely needs a frontier-tier model at all. Route it to a Budget-tier model (see the pricing table, filterable by tier) and the total bill is frequently 10–20× lower than running the same call through a Premium model, independent of the input/output ratio question entirely.

3. Long-form drafting / code generation (output-heavy)

Short instruction in, a long essay, report, or function implementation out. Output volume dominates — sometimes 5:1 or more against input — so the output rate drives the bill, and it's the number to optimize first. A model with a cheap input price but an expensive output price can be a bad deal here even though it looks affordable on a quick glance at the pricing table.

A simple test before you commit

1. Estimate your input:output token ratio from a handful of real requests — use the token counter to measure actual prompts rather than guessing.
2. Weight the pricing comparison accordingly. If you're roughly 80:20 input-heavy, a model's input rate should carry roughly 4× the weight of its output rate in your mental math (or use the workload toggle on cheapest models, which does exactly this weighting for you).
3. Sanity-check with a real cost example, not just a per-token rate — the compare tool prices a fixed representative job (1M input + 250K output tokens) across up to four models side by side so you're comparing dollars, not abstractions.
4. Confirm capability, not just cost. The cheapest model for your shape of traffic is only a good choice if it can actually do the task — check the benchmarks cost-vs-quality view before committing, especially for coding or agentic workloads.

Worked comparison

Take a workload of 1M input tokens and 250K output tokens per unit of work — a reasonable stand-in for a moderately long RAG query. Two illustrative models:

Here the first model wins because input dominates the token count. Flip the ratio to 250K input + 1M output (a drafting-heavy task) and the second model wins instead — $0.75 + $4.00 = $4.75 vs. $0.125 + $8.00 = $8.125. Same two models, opposite ranking, purely because the workload shape changed.

The takeaway

There is no single cheapest model — there's a cheapest model for your ratio. Measure your actual input:output split, weight the comparison accordingly, and re-rank periodically as your usage pattern or the market's prices change. Start with the cheapest models tool's workload toggle, confirm with the calculator using your real numbers, and check quality against cost on benchmarks before you lock in a choice.