AI model pricing guide: what each model actually costs

Quick answer: token prices span more than 100x.

Every major provider bills the same two ways: a rate per million input tokens and a higher rate per million output tokens. What changes between models is the number attached to each side, and that number moves in large steps. At the top, frontier reasoning and flagship models such as Claude Opus 4.7 and GPT-5.6 Sol list around $5 per million input tokens and $25 to $30 per million output tokens. At the bottom, budget models such as DeepSeek V4 Flash and DeepSeek V4 Pro list well under $1 per million tokens on both sides. That is roughly a 35x spread on input and close to 100x on output between the cheapest and priciest model most teams would actually put into production this year. Two things move a real bill more than the sticker price of any single model: the ratio of input to output tokens your workload actually produces, and whether you are paying each provider's list price directly or a discounted rate through a single gateway. The rest of this guide works through both with real numbers instead of a general rule of thumb.

How the bill is actually built.

Token pricing looks simple until you notice that "price" is really more than one number for some models. Every model has an input rate and an output rate, set independently and usually a wide margin apart. A growing share of current models add a third and fourth number on top: a premium rate to write a new entry into a prompt cache, and a steep discount to read that same entry back on a later call. GPT-5.6 Sol is a clean example of all four numbers living on one model. The input rate is the smallest of the four, the output rate runs six times higher, the cache-write rate sits above input, and the cache-read rate is a fraction of everything else. Reading only the headline input number and assuming that is "the price" is the single most common way people misjudge a model's real cost before they have sent a single request. Where the "official" number comes from also matters. Anthropic, OpenAI, Google, xAI, Zhipu AI, Moonshot AI, and MiniMax each set their own list price independently, and each one changes it on its own schedule as new versions ship. A gateway that carries many providers under one account can apply one consistent discount across all of them, which is a different lever from anything a single provider's pricing page controls.

Worked example: what three real workloads cost.

Model each workload by its actual input and output token volume instead of guessing from the input rate alone. A chatbot mostly re-reads a growing conversation and writes short replies, so input tokens dominate. Code generation and long-form writing return far more than they receive, so output tokens dominate instead. A high-volume classification or extraction job sends a lot of text through a small, cheap model and gets almost nothing back. The table below prices three daily workloads at each provider's official list rate against the same models at our discounted catalog rate, then projects the gap over 30 days. The workload shape, not the model name, decides which column moves the most.

Why the sticker price still surprises people.

None of this is exotic, it is just easy to miss when a pricing page shows one input number and one output number and stops there. Checking the actual token mix of a workload, and reading the fine print on any cache tier, avoids most of the surprise before a bill arrives. The fix is not to memorize every model's quirks. It is to price a workload the same way a provider does: input volume times input rate, plus output volume times output rate, and only then ask whether a cache tier changes the math because the same context gets reused.

• Output tokens usually cost three to six times more than input tokens, so any task that writes code, long prose, or a reasoning trace shifts most of the bill to the output side even when the prompt itself is short.
• Cache pricing looks like a built-in discount, but a cache-write fee only pays off if the same prefix actually gets read back on a later call. A cache written once and never reused is a pure extra cost, not a saving.
• A newer model version can ship with a different tokenizer that counts the same sentence as more tokens than the version before it, so a same-priced upgrade can still raise the real bill on identical input text.
• "Mini" and "flash" variants are not simply cheaper versions of the flagship in the same family. They are separate models with separate quality ceilings, so comparing purely on price without testing the real task creates a false saving.
• List prices are not permanent. Every provider in this guide has repriced or replaced a model within roughly the last year, so a saved pricing table is a snapshot, not a contract.

Full comparison: premium, mid, and budget tiers.

Grouping models by list price makes the tradeoffs easier to see than reading them one at a time. Premium models cluster around $5 input and $25 to $30 output. Mid-tier models sit between $2 and $3 input with output ranging from $6 to $15. Budget models keep input at $1 or under; output among the Chinese-provider models in this table ranges from under $1 for DeepSeek's tiers up to roughly $4 for Kimi K2.6. Official figures are each provider's own public list price; the right two columns are the same models at our catalog rate.

How to actually lower the bill.

That last lever changes where a request bills, not how you write it, which is why it stacks with every other item on this list. APIsRouter is an OpenAI-compatible gateway with pay-as-you-go billing and no subscription: global models such as the ones in the table above are priced 20% below official list, Chinese-provider models sit below their own official rates, the first top-up adds a 100% balance bonus, and the no-signup checkout at /topup takes payment first and emails the key. Swapping the base URL below is the only change an existing integration needs.

• Start with the cheapest model that can plausibly do the job and upgrade only when quality actually fails on your real inputs, instead of defaulting to the flagship for everything.
• Weigh output-heavy tasks differently. Code generation, long-form writing, and reasoning traces burn far more output than input, so a low output rate matters more there than a low input rate.
• Use cache pricing deliberately where a model supports it. A cache write only pays for itself across multiple reads of the same system prompt or long context, not a single call.
• Track spend per API key or per project, not just per invoice, so a workload that quietly shifted to a pricier model shows up before the monthly total does.
• Recheck official pricing pages on a quarterly cadence. Every provider in this guide has changed a rate or retired a model within roughly the last year.
• Lower the per-token rate itself by billing through a discounted OpenAI-compatible endpoint instead of paying each provider's direct list price.

Point an existing integration at the same catalog.

If a project already uses the OpenAI SDK or a plain HTTPS client, changing the rate it pays is a one-line edit: swap the base URL, keep the same request shape, keep the same model IDs. Verify a new key with a small request before wiring it into anything that matters.

from openai import OpenAI

client = OpenAI(
    api_key="sk-APIsRouter-...",
    base_url="https://api.apisrouter.com/v1",
)

response = client.chat.completions.create(
    model="claude-sonnet-4-6",  # swap for any catalog model ID
    messages=[{"role": "user", "content": "Reply with one word: ok"}],
)
print(response.choices[0].message.content)

FAQ