If you are trying to save money on LLM API spend, “cheaper” is not one number. It depends on the model, the input/output mix, whether you use batch routes, and how you buy credits. This page compares the standard per-token rates on five current models, then shows what that means at 100M tokens per month. It also lists the cases where OpenRouter is the cheaper option, because those exist.
Prices captured 2026-10-26 from both public price lists. USD per 1M tokens, standard non-batch routes.
What you are actually comparing
A token bill is the sum of four things: the input rate, the output rate, the share of tokens served from cache, and the route the gateway chooses. OpenRouter adds a marketplace dimension: the same model can be served by different upstream providers at different rates. JZS publishes one rate per model and routes through the upstream channels we operate.
That difference matters for budgeting. If you need a guaranteed number for a finance model, a single published rate is easier to defend than a range that moves with the route. If you need the absolute lowest price for an offline job, OpenRouter's batch routes can beat both standard rates.
OpenRouter pricing vs JZS on five models
The table uses a 3:1 input/output blend, which is close to what coding assistants and document workflows tend to produce. The blended column is the number to compare if you do not want to model your own mix yet.
| Model | OpenRouter in / out | JZS in / out | 3:1 blended (OR → JZS) | JZS saves |
|---|---|---|---|---|
| GPT-5.5gpt-5.5 | $5.00 / $30.00 | $0.39 / $2.34 | $11.250 → $0.876 | 92.2% |
| Claude Sonnet 5.5claude-sonnet-5.5 | $2.00 / $10.00 | $0.78 / $3.89 | $4.000 → $1.557 | 61.1% |
| DeepSeek V4 Prodeepseek-v4-pro | $0.96 / $1.91 | $0.45 / $2.25 | $1.194 → $0.898 | 24.8% |
| Qwen3.7 Maxqwen3.7-max | $1.48 / $4.42 | $0.78 / $2.34 | $2.213 → $1.168 | 47.2% |
| Gemini 4 Argongemini-4-argon | $2.00 / $10.00 | $0.39 / $1.95 | $4.000 → $0.778 | 80.5% |
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.
100M tokens per month
100M tokens is a useful scale for a small product or a heavy internal tool. These are list-price estimates for a single model at a 3:1 mix; caching, retries, and batch routing will move the actual bill.
| Model | OpenRouter / month | JZS / month | You keep |
|---|---|---|---|
| GPT-5.5 | $1125.00 | $87.57 | $1037.43 |
| Claude Sonnet 5.5 | $400.00 | $155.68 | $244.32 |
| DeepSeek V4 Pro | $119.41 | $89.82 | $29.59 |
| Qwen3.7 Max | $221.25 | $116.76 | $104.49 |
| Gemini 4 Argon | $400.00 | $77.84 | $322.16 |
100M tokens per month, 3:1 input/output, standard non-batch rates. These are list-price estimates, not a quote; your mix and caching will change the number.
A mixed workload
Most teams do not run one model. This example is 40% GPT-5.5, 25% Claude Sonnet 5.5, 20% DeepSeek V4 Pro, 10% Qwen3.7 Max, and 5% Gemini 4 Argon, all at a 3:1 input/output ratio:
OpenRouter / month
$616.01
JZS / month
$107.48
Difference
$508.52
Example mix: 40% GPT-5.5, 25% Claude Sonnet 5.5, 20% DeepSeek V4 Pro, 10% Qwen3.7 Max, 5% Gemini 4 Argon. This is an illustration, not a claim about your traffic.
Where the gap comes from
The large savings on GPT, Claude, Qwen, and Gemini are not a coupon or a temporary promotion. They come from the shape of the product:
- One published rate. We do not run a per-request marketplace where the provider, and therefore the price, changes underneath you. The number on the pricing page is the number used for billing.
- No separate platform fee. You buy prepaid USD credit and pay the per-token rate. There is no subscription, no monthly minimum, and no separate credit-purchase surcharge in our pricing.
- A shorter catalog. We support 69 models instead of 467. Fewer routes and fewer variants mean less operational surface to pay for — and a catalog we can actually test and support.
- The rate already includes our margin. We are not claiming to sell at upstream cost. The point is that the price you see is the whole price; there is no second layer added at checkout or at request time.
When OpenRouter is cheaper
This is the part most comparison pages skip. OpenRouter can be the cheaper choice in several situations:
Batch routes
OpenRouter's batch endpoints are often half the standard rate. If your workload is offline, latency-tolerant, and can wait for results, that discount can beat our standard price even on models where we are much cheaper on-demand. We do not offer a batch tier, so compare batch-to-batch or accept that you are paying for latency.
Long-tail and versioned model IDs
The table uses exact model IDs that both platforms list today. OpenRouter also carries dated snapshots and provider variants of the same family, and some of those can be cheaper than the base ID. If you are pinned to a specific snapshot, compare that snapshot, not the family name. We list one ID per model; if it is not in our catalog, we are not the cheaper option for that job.
Free models
OpenRouter lists free endpoints with rate limits. If your workload can live within those limits, free is cheaper than any paid rate. We do not offer free inference; the signup credit is a one-time trial, not a free tier.
A worked example: 8M input + 2M output
Blended per-1M numbers are useful for a first pass, but the monthly bill is what your finance team sees. Take a coding assistant that sends 8M input tokens and receives 2M output tokens in a month — a 4:1 mix, which is more input-heavy than the table above.
| Model | JZS | OpenRouter | Difference |
|---|---|---|---|
| GPT-5.5 | $7.78 | $100.00 | $92.22 |
| Claude Sonnet 5.5 | $14.01 | $36.00 | $21.99 |
| DeepSeek V4 Pro | $8.08 | $11.46 | $3.38 |
Standard non-batch rates, no cache. The percentage gap changes with the input/output mix; at the captured prices JZS is lower on both input and output for DeepSeek V4 Pro as well.
This is why the headline percentage is less useful than the absolute difference. A 92% saving on GPT is a large number because the OpenAI list price is high; the same percentage on a cheap model is a few dollars. If your volume is small, switch for predictability, not for the savings.
Hidden costs that change the answer
- Context replay. Agent loops resend the full history on every turn. Input tokens grow quadratically with conversation length; a 2× longer history can be 4× the input bill regardless of per-token price.
- Retries and failed requests. A rejected request may not be billed, but the retry is real traffic. Compare error rates, not just list prices; a cheaper model that fails 5% of the time is not cheaper.
- Cache hit rate. Cached input is priced differently on every model. If your prompts share a long prefix, cache pricing can matter more than the headline input rate. Check the cache columns on the pricing page.
- Output length. Output is 5–8× the input rate on many models. A prompt that encourages long reasoning can erase a large per-token saving.
- Engineering time. Self-hosting, dual-running, and reconciliation are real costs. A $30/month saving does not justify a week of migration work.
Five questions to ask any gateway
- What is the exact model ID, version, and standard (non-batch) price?
- Does the price change with the upstream route, or is it fixed per model?
- What happens on provider failover — same model, same price, or a silent substitution?
- Is there a separate platform fee, credit surcharge, or minimum commitment?
- Where does the request go, and which parties can see the prompt?
If a provider cannot answer those five in writing, the price table is not the problem. Those answers matter more than a one-cent difference per million tokens.
What a lower bill does not fix
A cheaper gateway is not a substitute for a cheaper workload. These costs are under your control and usually larger than the per-token difference:
- Sending the whole history every turn. Chat and agent clients often resend the entire conversation. The fix is prompt caching, summarization, or a sliding window — not a different vendor.
- Unbounded output. Output is the expensive side. A missing max_tokens and a model that likes to explain itself can double a request's cost.
- Retries without backoff. A retry storm multiplies spend and makes an upstream incident worse. Fix the retry policy before optimizing per-token price.
- Using a premium model for classification. A cheap model with a good prompt often beats a premium model with a vague one. Route by task, not by habit.
Three ways to lower the bill without switching
If you are not ready to migrate, these usually beat a 10–20% per-token difference:
- Cap output tokens and put the instruction to be concise in the system prompt.
- Keep stable prefixes at the front so the provider can serve cached input; check the cache price on your model.
- Use a smaller model for classification, extraction, and routing; reserve the expensive model for the final answer.
Do these first, then revisit the price table. A team that fixes context replay can cut its bill by more than the gateway comparison in a single sprint.
How to estimate your own bill
Do not trust a blended number blindly. Pull your actual input and output token counts for a representative period and apply the two rates separately, including the cached-token share. A simple formula:
monthly_cost =
input_tokens / 1_000_000 * input_price
+ output_tokens / 1_000_000 * output_price
+ cached_tokens / 1_000_000 * cache_read_priceFor a first pass, ignore cache and use the 3:1 blend from the table. For a serious migration, use your own token logs. Both platforms expose usage data; the shape of the formula is the same.
What switching actually costs
The migration is a base URL and a model-ID change. If your app uses the OpenAI SDK, you can run both gateways behind an environment variable and compare a week of real traffic before committing.
# OpenRouter OPENAI_BASE_URL=https://openrouter.ai/api/v1 MODEL=anthropic/claude-sonnet-5.5 # JZS OPENAI_BASE_URL=https://jzstoken.com/api/v1 MODEL=claude-sonnet-5.5
The step-by-step version is in How to migrate from OpenRouter. If you want the broader comparison first, see JZS Token vs OpenRouter.
FAQ
Is JZS cheaper for every workload?
No. The five-model table is a snapshot at standard non-batch rates. OpenRouter's batch routes, free endpoints, and versioned snapshots can be cheaper for specific jobs. Run your own token counts and compare the exact model ID.
Do you offer batch or free inference?
No batch tier and no free inference. The signup credit is a one-time trial while the current round lasts. If batch pricing is central to your workload, OpenRouter is the better fit for that part.
How is the savings percentage calculated?
The blended per-1M cost is (3 × input + output) / 4. The savings column is 1 - JZS / OpenRouter. The 100M table multiplies that blended cost by 100. No cache, no retries, no free tier.
Start saving
Create an account, put $5 on the balance, and run the same 100M-token estimate against your own traffic. If the math does not work for your mix, you have lost ten minutes, not a migration.
Start savingCheck current prices