I Spent Weeks Comparing AI API Prices — Here's What I Found

#ai #deepseek #tutorial #machinelearning

So here's what happened: i Spent Weeks Comparing AI API Prices — Here's What I Found

Last month my co-founder looked at our AWS bill and said something I'll never forget: "We're paying more for tokens than for the servers running them." That kicked off a three-week obsession of mine that turned into this post.

I've been building on top of LLM APIs for over three years now, and one thing has always bugged me — the way most providers treat their customers like hostages. Proprietary, closed source, walled garden pricing. You build your product, you commit to a vendor, and suddenly your roadmap bends to whatever they decide to charge next quarter. It feels gross.

So I pulled every price I could find, normalized them, sorted them, and stared at the results until patterns emerged. What I found honestly shocked me. The cheapest viable models aren't from the names you see splashed across conference keynotes. They're mostly Apache 2.0 and MIT licensed models that you could, in theory, self-host if you really wanted to. They're routed through Global API, which acts as a single endpoint for basically every major Chinese open-source model family.

Below is everything I learned. All numbers are pulled from Global API's pricing endpoint, verified May 2026. If you find a discrepancy, ping me — I update this every few months.

Why I Care About This (And Why You Should Too)

Look, I get it. Nobody starts a side project by worrying about API costs. You pick whatever model has the best demo, ship something, get users, and then the bill arrives. That's how I learned too. My first "real" AI product went from costing me $40/month to $4,000/month in six weeks flat.

The thing nobody tells you is that there's an enormous spread in pricing for what is, at the end of the day, very similar capability. A model that nails 92% on MMLU shouldn't cost 40× more than a model that nails 88%. And yet here we are, in 2026, with that exact dynamic playing out.

Worse, the closed-source incumbents have trained an entire generation of developers to assume that "good AI" means "expensive AI." That's nonsense. The MIT and Apache 2.0 model families out of China have been quietly catching up — and in some benchmarks, surpassing — the proprietary alternatives. The pricing reflects that gap. It also, conveniently, lets you route around the walled gardens.

The Price Tiers, From My Perspective

After sorting dozens of models, I started thinking about them in five buckets. This isn't a marketing taxonomy — it's how I actually decide what to reach for when I'm starting a new project.

Pencil-tier ($0.01–$0.10 per million output tokens). This is the "I don't care what this costs" zone. Run it all you want. Models here include Qwen3-8B, GLM-4-9B, Qwen2.5-7B, GLM-4.5-Air, and Qwen3.5-4B. They're tiny. They're MIT or Apache 2.0. They're not going to write your novel, but they'll absolutely handle classification, extraction, formatting, and short chat.

Coffee-tier ($0.10–$0.30 per million output tokens). This is where most production prototypes should live. DeepSeek V4 Flash lives here at $0.25, and frankly it's my default for almost everything. Hunyuan-Lite, Qwen2.5-14B, Step-3.5-Flash, ByteDance-Seed-OSS, Hunyuan-Standard, Hunyuan-Pro, ERNIE-Speed-128K, Qwen3-14B, Qwen3-32B, Hunyuan-TurboS, and Ga-Economy all sit in this band.

Lunch-tier ($0.30–$0.80 per million output tokens). When you need real quality. Qwen2.5-72B, DeepSeek-V3.2, Doubao-Seed-Lite, Ling-Flash-2.0, Qwen3-VL-32B, Qwen3-Omni-30B, GLM-4-32B, Hunyuan-Turbo, GLM-4.6V, Doubao-Seed-1.6, and DeepSeek V4 Pro.

Dinner-tier ($0.80–$2.00 per million output tokens). Reserved for things that genuinely need flagship reasoning. I'll dig into these below.

Mortgaged-house tier ($2.00–$3.50 per million output tokens). Only when I absolutely cannot compromise.

The Full 30-Model Ranking

Here's the complete list I compiled, sorted cheapest output price first. Everything is per million tokens, USD. Input price and context window are included because they matter for any non-trivial workload.

Rank	Model	Output $/M	Input $/M	Context	License vibes
1	Qwen3-8B	$0.01	$0.01	32K	Apache 2.0
2	GLM-4-9B	$0.01	$0.01	32K	MIT-ish
3	Qwen2.5-7B	$0.01	$0.01	32K	Apache 2.0
4	GLM-4.5-Air	$0.01	$0.07	32K	MIT-ish
5	Qwen3.5-4B	$0.05	$0.05	32K	Apache 2.0
6	Hunyuan-Lite	$0.10	$0.39	32K	Tencent terms
7	Qwen2.5-14B	$0.10	$0.05	32K	Apache 2.0
8	Step-3.5-Flash	$0.15	$0.13	32K	StepFun
9	Qwen3.5-27B	$0.19	$0.33	32K	Apache 2.0
10	ByteDance-Seed-OSS	$0.20	$0.04	128K	Open weights
11	Hunyuan-Standard	$0.20	$0.09	32K	Tencent terms
12	Hunyuan-Pro	$0.20	$0.09	32K	Tencent terms
13	ERNIE-Speed-128K	$0.20	$0.00	128K	Baidu
14	Qwen3-14B	$0.24	$0.20	32K	Apache 2.0
15	DeepSeek V4 Flash	$0.25	$0.18	128K	DeepSeek
16	Qwen3-32B	$0.28	$0.18	32K	Apache 2.0
17	Hunyuan-TurboS	$0.28	$0.14	32K	Tencent terms
18	Ga-Economy	$0.13	$0.18	Auto	Routing layer
19	Qwen2.5-72B	$0.40	$0.20	128K	Apache 2.0
20	DeepSeek-V3.2	$0.38	$0.35	128K	DeepSeek
21	Doubao-Seed-Lite	$0.40	$0.10	128K	ByteDance
22	Ling-Flash-2.0	$0.50	$0.18	32K	InclusionAI
23	Qwen3-VL-32B	$0.52	$0.26	32K	Apache 2.0
24	Qwen3-Omni-30B	$0.52	$0.30	32K	Apache 2.0
25	GLM-4-32B	$0.56	$0.26	32K	MIT-ish
26	Hunyuan-Turbo	$0.57	$0.18	32K	Tencent terms
27	GLM-4.6V	$0.80	$0.39	32K	MIT-ish
28	Doubao-Seed-1.6	$0.80	$0.05	128K	ByteDance
29	Ga-Standard	$0.20	$0.36	Auto	Routing layer
30	DeepSeek V4 Pro	$0.78	$0.57	128K	DeepSeek

A few observations from staring at this for too long:

The Qwen family is basically carrying the budget tier on its back. Most of their small models are Apache 2.0, which means if you ever decide the API route is too expensive, you can download the weights and run them yourself on a single GPU. That escape hatch is genuinely valuable.
Tencent's Hunyuan lineup clusters weirdly around the same price, which I suspect is intentional product positioning rather than coincidental economics.
The "routing" models (Ga-Economy, Ga-Standard) are interesting — they dynamically pick a model per request. Useful when you don't want to think about it.

What I'm Actually Using Day-to-Day

I'll be honest about my personal stack because I think this is where most "AI pricing" articles become useless. Nobody tells you which one they actually pick.

For classification, extraction, routing, and anything where the prompt fits in a few hundred tokens and the output is JSON: GLM-4.5-Air. At $0.01 output and $0.07 input, I don't even think about it. I had a logging pipeline that ran 14 million tokens through it last month and my bill was around $1.20. Try doing that with GPT-4o.

For general chat, RAG, and code generation that needs to be more than competent: DeepSeek V4 Flash at $0.25/$0.18. This is my default for everything that doesn't fall into the ultra-cheap bucket. The 128K context window means I can stuff entire documentation pages into it without breaking a sweat.

For multimodal (vision, audio): Qwen3-Omni-30B at $0.52/$0.30. Apache 2.0 license, multimodal, reasonable price. Done.

For when I genuinely need flagship reasoning and I'm willing to pay: DeepSeek-R1 sits around $2.40/M output, and there are a few Chinese models in the Kimi family that go up to $3.50/M. I use these maybe twice a week.

I'm not using the US-flagged proprietary models for anything customer-facing anymore. The combination of vendor lock-in, closed-source weights, and per-token pricing that resembles a Las Vegas buffet has me running for the exits. Apache 2.0 and MIT give me freedom — if the API goes down, if the company pivots, if the price triples, I can self-host.

A Quick Code Example (Python)

Here's how I actually call these models. Global API exposes everything through an OpenAI-compatible interface at https://global-apis.com/v1, which means your existing SDKs mostly just work:

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_GLOBAL_API_KEY",
    base_url="https://global-apis.com/v1"
)

response = client.chat.completions.create(
    model="GLM-4.5-Air",
    messages=[
        {"role": "system", "content": "Classify the sentiment. Reply with one word: positive, negative, or neutral."},
        {"role": "user", "content": "This product completely changed my workflow. Absolutely love it."}
    ],
    max_tokens=10,
    temperature=0
)
print(response.choices[0].message.content)
# Output: positive
# Cost: ~$0.0000014

That same call through GPT-4o would cost roughly 1,400× more. I did the math. Twice.

For something with more horsepower — say, generating a structured report from a long document:

response = client.chat.completions.create(
    model="DeepSeek V4 Flash",
    messages=[
        {"role": "system", "content": "You are a research analyst. Summarize the document into a JSON object with fields: summary, key_points, action_items."},
        {"role": "user", "content": long_document_text}
    ],
    response_format={"type": "json_object"},
    max_tokens=2000,
    temperature=0.3
)
report = response.choices[0].message.content