AI API Pricing Comparison 2026: Every Major Provider, All Numbers

Pricing updated 2026-08-19: AIWave V4 Flash is $0.638 input, $1.914 output, and $0.0203 cache hit; V4 Pro is $1.914 input, $5.742 output, and $0.0638 cache hit per 1M tokens.

With dozens of Chinese AI models available through a single API, choosing the right one for your budget is easier than you think.



Pricing for AI APIs is a mess. Every provider uses different tiers, different billing models, and different names for similar capabilities. This article puts every major model's pricing side by side so you can stop guessing and start optimizing.

Full Price Table (USD per 1M Tokens)

Sorted by total cost for a typical 1:1 input/output ratio. All prices are current as of July 2026 from AIWave's live pricing data.

Ultra-Cheap ($0.005–$0.04/1M)

Budget Tier ($0.01-0.05/1M)

Mid-Range ($0.05-0.15/1M)

Higher-End ($0.15-0.90/1M)

Western Providers (for comparison)

The rates that actually decide your bill

The tables above sprawl across 60+ models. In practice most AIWave traffic lands on a handful. These are the regular-tier rates AIWave reads from its own live pricing endpoint, USD per 1M tokens — the numbers worth memorizing:

Read a price table the way it will actually bill you

Three things separate the sticker price from the invoice, and every one of them favors reading the table more carefully:

Output is where the money is. Most workloads generate several output tokens per input token, and output is priced 2–5x higher. So sort by output, not input. qwen3-coder-480b at $0.360 output and deepseek-chat at $0.638 are effectively starter credits next to kimi-k2.5 at $1.914 — the same generated token costs 9x more on Kimi. Kimi earns that only when you genuinely need its long context; on ordinary generation it is the wrong default.

The cache column is a real discount, not a footnote. deepseek-chat drops from $0.638 to $1.914 on cached input, glm-1.914 from $0.930 to $0.220, kimi-k2.5 from $0.660 to $0.122 — roughly 76–81% off. If your prompts share a stable prefix (system instructions, tool schemas, a pinned document), design for the cache: constant material first, variable material last, byte-identical between calls.

Reasoning models bill you for thinking. deepseek-r1 at $2.409 output looks close to glm-4.7, but R1 emits its whole chain-of-thought as billable output, so the same question can produce 5–10x the tokens. The line item is output-rate × token-count, and reasoning inflates the second factor. Reserve it for problems that need multi-step deduction and route everything else to a conventional model.

Cost Calculation Formula

To estimate your monthly spend:

Monthly Cost = (Monthly Input Tokens / 1,000,000) × Input Price
             + (Monthly Output Tokens / 1,000,000) × Output Price

Practical example: Processing 10M input tokens and 20M output tokens per month:

That's not a typo. DeepSeek V4 Pro delivers comparable (or better) benchmark scores to GPT-4o at 10.7x lower cost.

The Chinese Model Advantage

Chinese AI providers consistently undercut Western pricing by 5-50x while maintaining competitive quality:

This isn't about compromising quality. DeepSeek V4 Pro scores 92.1 on HumanEval (vs GPT-4o's 90.2) and 90.2 on MATH (vs 76.6). You're paying less for equal or better performance.

Smart Model Selection Strategy

Token Cost Quick Reference

For a 1K token prompt producing 500 tokens of output:

At 10,000 calls/day, that's $0.00 vs $2.80 vs $8.40 vs $75.00. Scale makes the difference obvious.

See the live pricing page for the most current rates across all 60+ models. Sign up to start testing with your $0.20 starter credit. Join Discord to discuss cost optimization strategies with other developers.

Estimate your bill in code, not in a spreadsheet

The formula above is fine for a back-of-envelope, but the reliable way to know a model's cost on your traffic is to run real calls and read usage back. Every model on AIWave returns token counts in the same OpenAI-compatible shape, so one estimator covers all of them.

from openai import OpenAI

client = OpenAI(api_key="sk-your-aiwave-key", base_url="https://aiwave.live/v1")

PRICES = {  # USD per 1M tokens, regular tier
    "deepseek-chat": (0.638, 1.914),  # updated 2026-08-19
    "glm-4.7":       (0.930, 3.410),
    "kimi-k2.5":     (0.660, 3.300),
    "glm-5.1":       (2.100, 6.600),
}

def price(model, prompt):
    r = client.chat.completions.create(
        model=model, messages=[{"role": "user", "content": prompt}])
    pin, pout = PRICES[model]
    u = r.usage
    cost = u.prompt_tokens / 1e6 * pin + u.completion_tokens / 1e6 * pout
    print(f"{model:14} {u.prompt_tokens:>5} in + {u.completion_tokens:>5} out = ${cost:.6f}")

for m in PRICES:
    price(m, "Explain a B-tree in three sentences.")   # same prompt, four bills

Run that against 50–100 real inputs from your own traffic and you get the only cost comparison that matters: the actual token counts your prompts produce, not a vendor's example.

The same request in curl, piping usage through jq:

curl -s https://aiwave.live/v1/chat/completions \
  -H "Authorization: Bearer sk-your-aiwave-key" \
  -H "Content-Type: application/json" \
  -d '{"model":"glm-4.7","messages":[{"role":"user","content":"hi"}]}' \
  | jq '.usage'

And in Node, if your billing dashboard lives in JavaScript:

import OpenAI from "openai";

const client = new OpenAI({ apiKey: process.env.AIWAVE_KEY, baseURL: "https://aiwave.live/v1" });
const prices = { "deepseek-chat": [0.638, 1.914], "kimi-k2.5": [0.660, 3.300] };

const model = "deepseek-chat";
const r = await client.chat.completions.create({
  model, messages: [{ role: "user", content: "Explain a B-tree in three sentences." }],
});
const [pin, pout] = prices[model];
const cost = (r.usage.prompt_tokens / 1e6) * pin + (r.usage.completion_tokens / 1e6) * pout;
console.log(model, r.usage.prompt_tokens, "in", r.usage.completion_tokens, "out", "$" + cost.toFixed(6));

Wire this into a cheap-first router — run the most cost-effective model, keep the ones that pass, re-run only the failures on a stronger model — and the pricing table stops being trivia and starts being your monthly savings.

Ready to put this to the test? Sign up for AIWave and get $0.20 starter credit to try it yourself. No credit card needed.

We're a small team behind AIWave. No VC money, no big marketing budget — just a few people who believe Chinese AI models should be accessible to everyone in the world. Your API calls keep this project alive. If you find value in what we're building, stick around. It means more than you know.

Costs the sticker price hides

Per-token rates are only the visible layer. Three others move the real number:

• Retries and failures. Every 429 you back off from and every malformed response you re-request is tokens spent for no output. High-throughput cheap models fail less often at a given load — a cost advantage the rate card never shows.
• Prompt bloat. A 2,000-token system prompt you never trimmed rides along on every call. On 10M calls that is 20B tokens of pure overhead, and only the cache rate partly rescues it.
• Over-provisioned models. Routing everything to a $2.100/1M model because it is "the good one" is the most expensive habit in this article. The fix is difficulty-based routing, below.

The cheap-first router, in full

The strategy that beats any single-model choice: run the most cost-effective capable model, keep the answers that pass a check, and re-run only the failures on a stronger model. Because every model shares the OpenAI-compatible shape, escalation is a string swap.

from openai import OpenAI

client = OpenAI(api_key="sk-your-aiwave-key", base_url="https://aiwave.live/v1")
LADDER = ["deepseek-chat", "glm-4.7", "glm-5.1"]   # cheap -> capable

def answer(prompt, passes):
    out = None
    for model in LADDER:
        resp = client.chat.completions.create(
            model=model, messages=[{"role": "user", "content": prompt}])
        out = resp.choices[0].message.content
        if passes(out):            # your validator: schema, tests, a rubric
            return model, out
    return LADDER[-1], out          # fell through: best effort

# most traffic resolves on deepseek-chat at $0.638/$1.914;
# only the hard slice reaches glm-5.1 at $2.100/$6.600

The savings live in step two. If 85% of your traffic passes on deepseek-chat, you pay the cheap rate on 85% of calls and the expensive rate on 15% — a blended cost far below standardizing on the strong model, and far more reliable than standardizing on the weak one. The validator is the hard part and the part worth your time: a JSON schema check, a unit test on generated code, or a second cheap model scoring the answer.

What "starter credits" actually costs

starter credits tiers like GLM 4.7 Flash are real and useful for prototyping, but "starter credits" has a ceiling — rate limits and no throughput guarantee under load. Treat them as the first rung: validate an idea on the starter tier, then move the workload to a paid model with predictable limits before you ship. The paid rates in the authoritative table are low enough ($0.638 input on deepseek-chat) that the jump from starter credits to reliable is single-digit dollars a month for most side projects.

Why Chinese providers price this far below Western ones

The 5–50x gap is not a loss-leader promotion. It comes from structural things: years of intense domestic price competition, lower training and serving costs, and models like DeepSeek-V3 and GLM engineered for inference efficiency rather than maximum parameter count. The result is a genuine price floor, not a temporary sale — deepseek-chat at $0.638 input and near-starter credits GLM Flash tiers are the steady state. What AIWave adds is access: USD, card payments, and Stripe billing, an OpenAI-compatible endpoint, and Email or GitHub account options, so a developer anywhere can reach those rates without a domestic account.

Context window is a cost lever, not just a feature

A big window is not starter credits even when the input price is low, because you pay for every token you put into it. The 1M-context models are genuinely useful when a task needs them, but padding prompts with "just in case" context is how a $0.638 input rate turns into a real bill. Send the minimum context that answers the question, and let retrieval — not a giant prompt — decide what the model sees.

Cutting your bill this week

1. Sort candidates by output price, not input. Output dominates most workloads and varies more — $0.001 to $22.5 across the table above.
2. Turn on the cache. Move every constant (system prompt, tool schemas, pinned docs) to the front, byte-identical between calls, and claim the 76–81% prefix discount.
3. Cap output. Set max_tokens on every call so a rambling completion cannot multiply the expensive half of the bill.
4. Route by difficulty. Cheap model first, escalate only failures. This one change usually beats any model swap.
5. Measure on your own traffic. Run the estimator above over 50–100 real prompts. Vendor example costs never match your token counts.

None of this requires switching frameworks or rewriting prompts. It is base_url, model strings, prompt ordering, and a validator — and it is the difference between a $60 month and a $6 one.