Cheapest LLM API for production workloads

"Cheapest" is a ranking, not an opinion, so this page doesn't argue for one — it's computed live from the same dataset behind the rest of Meterlark, sorted by input rate. The table changes whenever a provider changes a price. What follows is how to actually use a ranking like this instead of just picking the top row.

Input rate isn't the whole story

A model with the lowest input rate can still be more expensive in practice if its output multiple is high and your workload is generation-heavy. Before picking anything off this list for production, check that same model's output rate and run your actual token shape through the calculator — the ranking above is a starting point for a shortlist, not a final answer.

What you typically give up at the low end

• Reasoning depth on multi-step or ambiguous tasks — the cheapest tiers are built for volume, not complexity.
• Context window size — some low-cost models cap out well below the flagship tier from the same provider.
• Capability flags — vision, tool use and extended thinking are less consistently available on the smallest models; check the model page's capability list before assuming a cheap model can do the job.
• Consistency on edge cases — smaller models tend to have a wider variance in output quality on tasks near the edge of their ability.

Price per token isn't the same as cost per correct answer

A model that's cheaper per token but needs a retry, a longer prompt to get the same result, or a second verification pass can end up costing more per successfully completed task than a pricier model that gets it right the first time. This ranking is a per-token comparison, which is the right first filter — but the real decision should be made against your task's actual accuracy bar, using a small representative eval, not the price column alone.

Where the cheapest tier is genuinely the right call

High-volume, low-ambiguity tasks are exactly what these models are priced for: classification, tagging, short extraction, intent routing, simple chat turns with a narrow scope. If your task fits that description, paying a premium-tier rate for it is pure waste — route it to the cheapest model that clears your accuracy bar, and reserve the expensive tier for the requests that actually need it.

• Intent routing and short chat replies with a narrow, well-defined scope.
• Tagging and metadata extraction from structured or semi-structured input.
• First-pass moderation or triage before escalating flagged items to a stronger model.
• Any task you can validate cheaply — where a wrong answer is low-stakes and easy to catch downstream.

A routing pattern worth considering

Rather than picking one model for an entire application, many production systems route by task: a cheap model handles classification or a first-pass attempt, and only escalates to a premium model when the task is flagged as complex or the cheap model's confidence is low. That pattern captures most of the savings on this page without giving up quality on the requests that need it.

Compare any two candidates from this list directly — same worked examples, side by side — on the comparison pages before committing to one.

Caveat on caching and batch

The ranking above is standard, synchronous pricing. A mid-tier model with strong caching or batch discounts can beat a nominally cheaper model once those apply to your actual traffic pattern — see prompt caching cost savings explained and batch API discounts, when to use them before finalizing a choice based on the standard rate alone.

Don't forget reliability and rate limits

"Cheapest" says nothing about how consistently a provider serves that price at your volume. Rate limits, regional availability, and how a provider handles sustained high-throughput traffic all vary, and none of it shows up in a per-token comparison. If you're choosing a model for a production workload rather than a one-off script, treat this ranking as your shortlist filter, then confirm the provider's actual throughput and reliability at the volume you plan to run before committing.