Cheapest LLM API in 2026: what the price list does not tell you

The cheapest model per token is not always the cheapest way to finish a task. A cheap model that needs two retries, produces longer output, or fails on tool calls can cost more than a slightly expensive one. This page starts with the actual per-token ranking, then shows where the ranking breaks — and which model is the cheapest sensible choice for Claude, GPT, DeepSeek, and Qwen workloads.

Prices captured 2026-10-26 from JZS and OpenRouter public price lists. USD per 1M tokens, standard non-batch routes.

What “cheapest” should mean

There are three different numbers people call price:

• Input price. What you pay to send context. It matters most for long documents, RAG, and agent loops that replay history.
• Output price. What you pay for generated tokens. Output is usually 4–8× the input rate, and it is the line that grows when a model rambles.
• Blended price. A single number for a given input/output mix. We use 3:1 here, which matches coding assistants and document Q&A more closely than a 1:1 assumption.

A fourth number matters just as much: cost per successful task. It includes retries, failed tool calls, and output that had to be regenerated. A cheap model with a 10% failure rate is not cheap.

The cheapest models on JZS, by blended price

Sorted by JZS blended price at 3:1. The OpenRouter column is there so you can see where the ranking flips; it is not a claim that JZS wins every row.

USD per 1M tokens, standard (non-batch) routes, captured 2026-10-26. Blended assumes 3 input tokens per output token. OpenRouter batch routes are often half price and are not compared here.

Sources: JZS public pricing API and OpenRouter public model list, both read on 2026-10-26. Prices move; check both pages before you commit to a provider.

How to read this table

The first two rows are the budget tier: GPT-5.6 Luna and GPT-6 Luna at roughly $0.16–$0.18 per 1M blended. They are fine for classification, extraction, simple chat, and routing, but they are not a substitute for a frontier model on complex reasoning or long tool-use loops.

The middle tier is where most production traffic belongs: DeepSeek V4.1 Flash, Qwen3.8 Flash, GLM-5.3 Flash, GPT-6 Sol, Gemini 4 Argon, GPT-5.5, DeepSeek V4 Pro, and Qwen3.7 Max. The last three rows — Claude Sonnet 5.5 and Claude Opus 5.5 — are the premium tier, and they are still far below OpenRouter's list price.

Note the rows where OpenRouter is cheaper: DeepSeek V4.1 Flash, Qwen3.8 Flash, and GLM-5.3 Flash. If your workload is concentrated on those exact IDs, the price argument for switching is weak. The comparison is honest about that.

The cheapest way to use Claude

Claude is not the cheapest model family, but it is often the cheapest way to get a reliable answer on a hard coding or analysis task without retries. Within the family, the ranking is simple:

USD per 1M tokens, standard (non-batch) routes, captured 2026-10-26. Blended assumes 3 input tokens per output token. OpenRouter batch routes are often half price and are not compared here.

Claude Sonnet 5.5 is the default. At $0.78 input / $3.89 output per 1M on JZS, it is roughly 61% cheaper than OpenRouter's standard rate on the same model. Claude Opus 5.5 is for the tasks where Sonnet fails or where the cost of a wrong answer exceeds the token bill; do not route routine classification to Opus.

The practical rule: use Sonnet for most of the work, escalate a narrow slice to Opus, and keep a cheap model for extraction and routing. That mix usually costs less than running Opus everywhere, even at Opus's lower JZS price.

Cheapest GPT, DeepSeek, and Qwen options

GPT

GPT-5.6 Luna is the cheapest OpenAI model we list at $0.0778 input / $0.3892 output per 1M. GPT-6 Luna is close behind at $0.0778 / $0.4671. GPT-5.5 is the step up for harder reasoning; it is still about $0.39 / $2.34 per 1M on JZS versus $5 / $30 on OpenRouter. If you are migrating from GPT-4o, GPT-5.5 is the current equivalent in our catalog; GPT-4o itself is not offered.

DeepSeek

DeepSeek V4.1 Flash is the cheapest DeepSeek option at $0.1497 / $0.7485 per 1M, but OpenRouter is cheaper for it at $0.02 input / $1.00 output. DeepSeek V4 Pro is the other way around: $0.4491 / $2.2455 on JZS versus $0.95526 / $1.91052 on OpenRouter. If you use DeepSeek heavily, compare the exact ID, not the family name.

Qwen

Qwen3.8 Flash is the budget option at $0.1557 / $0.7784 per 1M; OpenRouter is cheaper on both rates for that ID. Qwen3.7 Max is the step up at $0.7784 / $2.3353, versus $1.475 / $4.425 on OpenRouter. Pick the Flash tier for volume and Max for quality-sensitive work.

The cheapest option by provider

What 10M tokens actually costs

A smaller, easier-to-check version of the monthly math. This is 10M tokens at a 3:1 input/output mix, list prices only:

The absolute differences on the Flash models are small because the prices are already low. The big numbers are on GPT-5.5 and Claude Opus, where a 10M-token month is the difference between a $9 bill and a $113 bill on the same model.

What you give up at the cheap end

• Reasoning depth: a Luna model is not a substitute for Opus or GPT-5.5 on multi-step coding.
• Instruction following: cheap models need tighter prompts and more validation.
• Tool reliability: fewer retries on a frontier model is often cheaper per completed task.
• Long context: check the context window and output limit on the exact ID before moving a long-document workload.

Why the cheapest model can be the most expensive

• Retries. A cheap model that fails at tool calls or truncates output sends the request twice. At a 10% retry rate, a 20% price advantage disappears.
• Output length. Cheap models sometimes explain more than expensive ones. If the cheap model writes 2× the output, the output-price difference can erase the input saving.
• Context replay. Agent frameworks resend history every turn. A cheap input rate on a long conversation still adds up; caching and summarization matter more than the per-token gap.
• Engineering time. A model that needs prompt re-tuning or a fallback chain is not cheaper after you pay for the engineering.

When OpenRouter is the cheaper option

Three cases are worth repeating: OpenRouter's batch routes are often half price for latency-tolerant jobs; its free endpoints can be cheaper than any paid tier; and on the three Flash models above, its standard rate is lower than ours. If those are your workloads, stay where you are or split the workload instead of migrating everything.

The broader price table in LLM API pricing comparison 2026 includes every row above, and the cheaper-than-OpenRouter breakdown shows the 100M-token monthly math.

How to keep the bill low

• Route by task: a cheap model for classification/extraction, a mid-tier model for drafting, a premium model only for final answers.
• Cap output tokens and ask for concise answers; output is the expensive side.
• Keep stable prefixes at the front so cached input can be reused where the model supports it.
• Measure cost per successful task, not cost per token; include retries and regenerations.
• Re-check prices monthly; both gateways update them, and the cheapest model changes.

Moving from OpenRouter in five steps

1. Export one week of usage by model ID: input tokens, output tokens, retries, and error codes.
2. Mark the IDs where JZS is cheaper and leave the rest on OpenRouter. A partial migration is the intended outcome, not a failure.
3. Create a key, point the base URL at https://jzstoken.com/api/v1, and map each model ID explicitly. Do not rely on family-name aliases.
4. Send 1% of traffic for 48 hours. Compare error rate, latency, output quality, and token accounting against the same requests on the old gateway.
5. Cut over one model at a time and keep the old key during the first billing cycle. Rollback is a base-URL change, not a data migration.

Measure cost per successful task

Pick one representative task — a support reply, a file edit, an extraction — and log three numbers for a week: tokens in, tokens out, and whether the task succeeded without human correction. Multiply the tokens by the model's rates and divide by successful tasks. That is your real unit cost.

Example with list prices only: a 3K-token extraction task on GPT-5.6 Luna costs about $0.00047, and on Claude Sonnet 5.5 about $0.0047 — roughly 10×. A 10% retry rate on Luna raises its cost by 10%, not by 2×; the cheap model stays cheaper per call. The expensive model wins when it reduces human corrections by more than the per-token gap, which is exactly what the metric captures.

This is also the honest answer to “which gateway is cheaper”: the one whose model plus retry rate plus human review costs less per finished task. The per-token ranking is the input to that calculation, not the answer.

FAQ

Which LLM API is actually the cheapest?

On a 3:1 blend, the cheapest rows in this catalog are GPT-5.6 Luna at $0.156 per 1M and the three Flash models at roughly $0.30. On the specific IDs we checked, OpenRouter's standard rate is lower for DeepSeek V4.1 Flash, Qwen3.8 Flash, and GLM-5.3 Flash. For Claude and GPT-5.5, JZS is substantially cheaper. There is no single cheapest gateway; it depends on which model ID you need.

What is the cheapest Claude API?

Claude Sonnet 5.5 is the cheapest Claude model in this catalog at $0.7784 input and $3.8922 output per 1M, or $1.557 blended at 3:1. Claude Opus 5.5 is $1.1677 / $5.8383, or $2.335 blended. Both are below OpenRouter's $2 / $10 and $4 / $20 list prices for the same IDs.

Should I move everything to the cheapest gateway?

No. Split by model ID. Move the IDs where the gateway you are leaving is more expensive, keep the IDs where it is cheaper, and route the rest by task. A blanket migration gives up the rows you were winning and saves less than the table suggests.

Is the cheapest model good enough for coding?

For autocomplete, small refactors, and test generation, yes. For multi-file changes, architecture reviews, and debugging a failure that spans several services, the retry rate on a budget model usually makes it more expensive per finished task. The practical pattern is a cheap model for the loop and a frontier model for the decisions.

Start with the cheapest sensible model

Create an account, check the live price of the model you actually plan to use, and send one request. The catalog shows input, output, and cache prices per 1M tokens.