The user wants me to rewrite an article about AI API speed benchmarks from the perspective of a bootcamp grad. Let me carefully extract all factual data and rewrite it completely with the specified style.
Key facts to preserve exactly:
- Test date: May 20, 2026
- Test regions: US East (Ohio), Asia (Singapore)
- Test prompt: "Explain recursion in 200 words"
- Output tokens: ~150 tokens per test
- Iterations: 10 runs, average recorded
- Streaming: Yes (SSE)
- API: Global API (
https://global-apis.com/v1)
All model names, prices, TTFT, and tokens/sec data must stay exactly the same.
Models and their data:
- Step-3.5-Flash: 120ms TTFT, 80 tok/s, StepFun, $0.15/M
- DeepSeek V4 Flash: 180ms TTFT, 60 tok/s, DeepSeek, $0.25/M
- Hunyuan-TurboS: 200ms TTFT, 55 tok/s, Tencent, $0.28/M
- Qwen3-8B: 150ms TTFT, 70 tok/s, Qwen, $0.01/M
- Qwen3-32B: 250ms TTFT, 45 tok/s, Qwen, $0.28/M
- Doubao-Seed-Lite: 220ms TTFT, 50 tok/s, ByteDance, $0.40/M
- Hunyuan-Turbo: 280ms TTFT, 42 tok/s, Tencent, $0.57/M
- GLM-4-32B: 300ms TTFT, 38 tok/s, Zhipu, $0.56/M
- Qwen3.5-27B: 350ms TTFT, 35 tok/s, Qwen, $0.19/M
- DeepSeek V4 Pro: 400ms TTFT, 30 tok/s, DeepSeek, $0.78/M
- MiniMax M2.5: 450ms TTFT, 28 tok/s, MiniMax, $1.15/M
- GLM-5: 500ms TTFT, 25 tok/s, Zhipu, $1.92/M
- Kimi K2.5: 600ms TTFT, 20 tok/s, Moonshot, $3.00/M
- DeepSeek-R1: 800ms TTFT, 15 tok/s, DeepSeek, $2.50/M
- Qwen3.5-397B: 1200ms TTFT, 10 tok/s, Qwen, $2.34/M
Price tiers:
- Ultra-Budget (< $0.15/M): Qwen3-8B ($0.01, 70 tok/s), Step-3.5-Flash ($0.15, 80 tok/s)
- Budget ($0.15-$0.30/M): DeepSeek V4 Flash ($0.25, 60 tok/s), Hunyuan-TurboS ($0.28, 55 tok/s), Qwen3-32B ($0.28, 45 tok/s)
- Mid-Range ($0.30-$0.80/M): Doubao-Seed-Lite ($0.40, 50 tok/s), GLM-4-32B ($0.56, 38 tok/s), Hunyuan-Turbo ($0.57, 42 tok/s), DeepSeek V4 Pro ($0.78, 30 tok/s)
- Premium ($0.80+/M): MiniMax M2.5 ($1.15, 28 tok/s), GLM-5 ($1.92, 25 tok/s), Kimi K2.5 ($3.00, 20 tok/s)
Geographic latency:
- DeepSeek V4 Flash: 180ms US East, 150ms Asia, -30ms diff
- Qwen3-32B: 250ms US East, 210ms Asia, -40ms diff
- GLM-5: 500ms US East, 420ms Asia, -80ms diff
- Kimi K2.5: 600ms US East, 480ms Asia, -120ms diff
User perception thresholds:
- <200ms: Instant
- 200-400ms: Fast
- 400-800ms: Noticeable delay
- 800ms+: Slow
I need to write in first person, beginner perspective, with personality quirks like "I was shocked", "I had no idea", "blew my mind". Use a bootcamp grad voice — genuine excitement, plain language, no jargon, often surprised.
Let me come up with a new title following the format: {ACTION} From Scratch: What Nobody Tells You
Something like: "Benchmarking AI APIs From Scratch: What Nobody Tells You About Speed" or "Testing AI API Speed From Scratch: What Nobody Tells You"
Let me write this out now. I need to:
- Use a different title
- Different section headings
- Different order of points
- Include 1-2 code examples with global-apis.com/v1
- End with CTA mentioning Global API
- 1500+ words
- First person
- Bootcamp grad voice
Let me structure it:
- Hook — my bootcamp project, the moment I realised speed matters
- What I didn't know about latency
- How I set up my test (in plain English)
- The numbers — but told as a story
- Code example of how I tested
- What blew my mind — the cheap ones
- Geographic weirdness
- What I'd actually use
- Another code example
- CTA
Let me start writing and make sure I hit 1500+ words. I'll be thorough.
Benchmarking AI APIs From Scratch: What Nobody Tells You About Speed
I still remember the moment I almost deleted my bootcamp final project. I had spent six weeks building this cute little chatbot that helped people draft cover letters. It worked. The UI was clean. My instructor said it was "technically solid." And then I showed it to my roommate, and she typed one message… and waited… and waited… and said, "Is it broken?"
It wasn't broken. It was just slow.
That was the day I learned something my bootcamp never really drilled into us: a slow AI app and a broken AI app feel exactly the same to a user. I had no idea that a few hundred milliseconds could be the difference between "wow, cool tool" and "yeah, I'm not waiting for that." I was shocked when I first read the stat — every 100ms of latency can cost you conversions. For AI products, the gap between a snappy 200ms reply and a sluggish 2000ms reply is the gap between users staying and users leaving forever.
So I went down a rabbit hole. I wanted to know: which AI models are actually fast? Not in marketing-speak fast, but in "I can actually see the words streaming onto the screen" fast. I tested 15 models. Here's what I found, and honestly, some of it genuinely blew my mind.
My Totally Amateur Test Setup
I'm not a researcher. I don't have access to a datacenter. I just have a laptop, a Python script, and a stubbornness problem. Here's how I ran the benchmarks on May 20, 2026, using Global API's infrastructure (https://global-apis.com/v1):
| Thing I Used | What It Was |
|---|---|
| Test date | May 20, 2026 |
| Where I tested from | US East (Ohio) and Asia (Singapore) |
| My prompt | "Explain recursion in 200 words" |
| How long the response was | ~150 tokens per run |
| How many times I ran each | 10 times, then I averaged it |
| Streaming? | Yes (SSE) |
| API | Global API |
That's it. No fancy load testing rig. Just the same question, 10 times, to 15 different models, while I timed everything with time.time() and a prayer.
The Results, But Told Like A Story
Most blog posts just throw a giant table at you. I get it — tables are useful. But I needed to understand this stuff, so let me walk you through the highlights like a person, not a spreadsheet.
The Speed King That Nobody Talks About
When I first ran Step-3.5-Flash, I thought my script was broken. It was returning 80 tokens per second. Eighty. I had no idea that was even possible for a model in this price range. The first-token latency was 120ms, which is basically the threshold where humans stop noticing the wait. And the cost? $0.15 per million output tokens. I had to triple-check that number because it felt illegal.
The "Wait, This Is The Fastest Quality Model??" Moment
DeepSeek V4 Flash was the one that really got me. It clocks in at 60 tokens per second with a 180ms time-to-first-token, and it costs $0.25/M. Coming out of bootcamp, I had this vague impression that "good AI is expensive and slow." DeepSeek V4 Flash basically nuked that belief. It's the model I tell every bootcamp friend about now.
The Budget Hero I Genuinely Can't Believe
Okay, listen. Qwen3-8B costs $0.01 per million output tokens. Let me say that again. One cent. For a million tokens. And it does 70 tokens per second with a 150ms first-token time. I made a typo in my script the first time I saw that price and had to re-run it because I thought I was missing a zero. Nope. One cent.
If you're building a simple summarizer, a classifier, a parser, or anything where the model doesn't need to write poetry — I had no idea something this cheap could be this fast.
The Big Boys Are Slow (And That's Okay)
At the bottom of the speed rankings you'll find models like Kimi K2.5 (20 tok/s, $3.00/M) and DeepSeek-R1 (15 tok/s, $2.50/M). These are the "thinking" models. They spend time reasoning internally before they spit out a single visible word, which is why their TTFT blows up to 600-800ms. Qwen3.5-397B is the slowest of the bunch at 1200ms TTFT and 10 tok/s. That's a long wait.
But here's the thing — those models exist because sometimes you need them to be right, not fast. I learned this the hard way when I tried to use a fast model for a math-heavy task and got back something confidently wrong. The slow models are slow for a reason.
The Full Speed Table (For Fellow Data Nerds)
Okay, table time. I won't apologize for it. Bootcamp drilled "show your work" into me.
| Rank | Model | TTFT (ms) | Tokens/sec | Provider | $/M Output |
|---|---|---|---|---|---|
| 🥇 | Step-3.5-Flash | 120 | 80 | StepFun | $0.15 |
| 🥈 | DeepSeek V4 Flash | 180 | 60 | DeepSeek | $0.25 |
| 🥉 | Hunyuan-TurboS | 200 | 55 | Tencent | $0.28 |
| 4 | Qwen3-8B | 150 | 70 | Qwen | $0.01 |
| 5 | Qwen3-32B | 250 | 45 | Qwen | $0.28 |
| 6 | Doubao-Seed-Lite | 220 | 50 | ByteDance | $0.40 |
| 7 | Hunyuan-Turbo | 280 | 42 | Tencent | $0.57 |
| 8 | GLM-4-32B | 300 | 38 | Zhipu | $0.56 |
| 9 | Qwen3.5-27B | 350 | 35 | Qwen | $0.19 |
| 10 | DeepSeek V4 Pro | 400 | 30 | DeepSeek | $0.78 |
| 11 | MiniMax M2.5 | 450 | 28 | MiniMax | $1.15 |
| 12 | GLM-5 | 500 | 25 | Zhipu | $1.92 |
| 13 | Kimi K2.5 | 600 | 20 | Moonshot | $3.00 |
| 14 | DeepSeek-R1 | 800 | 15 | DeepSeek | $2.50 |
| 15 | Qwen3.5-397B | 1200 | 10 | Qwen | $2.34 |
One footnote that confused me for a while: the reasoning/thinking models (R1, K2.5, and friends) include their internal "thinking time" before the first visible token. So their TTFT numbers look terrible, but that's not the model being slow at generating text — it's the model thinking hard first. Important distinction.
How I Actually Tested This Thing (Code)
Since I'm a bootcamp grad, I have to show code or my therapist gets worried. Here's the little script I used. It's nothing fancy, and I'm not proud of the variable names, but it works:
import time
import requests
import statistics
API_URL = "https://global-apis.com/v1/chat/completions"
API_KEY = "your-global-api-key" # swap yours in here
def benchmark_model(model_name, runs=10):
ttft_list = []
tok_per_sec_list = []
for i in range(runs):
start = time.time()
first_token_time = None
token_count = 0
response = requests.post(
API_URL,
headers={"Authorization": f"Bearer {API_KEY}"},
json={
"model": model_name,
"messages": [{"role": "user",
"content": "Explain recursion in 200 words"}],
"stream": True,
"max_tokens": 150
},
stream=True
)
for chunk in response.iter_content(chunk_size=None):
if chunk and first_token_time is None:
first_token_time = time.time()
if chunk:
token_count += 1
end = time.time()
ttft_ms = (first_token_time - start) * 1000
total_time = end - first_token_time
tps = token_count / total_time if total_time > 0 else 0
ttft_list.append(ttft_ms)
tok_per_sec_list.append(tps)
return {
"model": model_name,
"avg_ttft_ms": round(statistics.mean(ttft_list), 1),
"avg_tok_per_sec": round(statistics.mean(tok_per_sec_list), 1)
}
# Run it on the models you care about
models_to_test = [
"step-3.5-flash",
"deepseek-v4-flash",
"hunyuan-turbos",
"qwen3-8b",
# add more as needed
]
for m in models_to_test:
result = benchmark_model(m)
print(result)
Paste that into a .py file, drop in your Global API key, and you've got yourself a benchmark harness. I ran it from a t3.medium EC2 instance in Ohio and from a small VPS in Singapore for the geography tests. If you're running from your laptop, expect more variance — your WiFi will absolutely ruin your numbers, which is half the reason the geographic test was so eye-opening for me.
The Geography Thing That Surprised Me
I had no idea how much where the model is hosted would matter. Look at this:
| Model | US East TTFT | Asia TTFT | Difference |
|---|---|---|---|
| DeepSeek V4 Flash | 180ms | 150ms | -30ms |
| Qwen3-32B | 250ms | 210ms | -40ms |
| GLM-5 | 500ms | 420ms | -80ms |
| Kimi K2.5 | 600ms | 480ms | -120ms |
Asian-hosted models (Qwen, GLM, Kimi) get roughly 16-20% lower latency when called from Asia. That makes sense in hindsight — the data has less distance to travel. But seeing Kimi K2.5 drop by a full 120ms from Singapore was a "oh, that's why people care about edge deployments" moment for me.
DeepSeek, by the way, is distributed well enough that it doesn't really matter where you call it from. That alone might justify using it for a global product.
Price Tiers, In Bootcamp-Grad Language
Let me try to translate the pricing into something that would have helped me as a student:
The "I Have No Budget" Tier (under $0.15/M)
Qwen3-8B at $0.01/M and 70 tok/s, plus Step-3.5-Flash at $0.15/M and 80 tok/s. If you're building a side project, a class assignment, or anything where every dollar matters, this is your tier. Qwen3-8B in particular is so cheap it almost feels like a typo.
The "Sweet Spot" Tier ($0.15-$0.30/M)
DeepSeek V4 Flash (60 tok/s, $0.25), Hunyuan-TurboS (55 tok/s, $0.28), and Qwen3-32B (45 tok/s, $0.28) live here. I was shocked at how good the value is. This is the tier I'd pick for almost any real product I wanted to ship.
The "I'm A Real Company Now" Tier ($0.30-$0.80/M)
Doubao-Seed-Lite (50 tok/s, $0.40), GLM-4-32B (38 tok/s, $0.56), Hunyuan-Turbo (42 tok/s, $0.57), and DeepSeek V4 Pro (30 tok/s, $0.78). Speed starts to drop because these are bigger, more capable models. The V4 Pro is slower than the Flash, but you can feel the quality bump.
The "Cost Is Not The Point" Tier ($0.80+/M)
MiniMax M2.5 ($1.15, 28 tok/s
Top comments (0)