I Benchmarked 15 AI APIs at 3am So You Don't Have To

I Benchmarked 15 AI APIs at 3am So You Don't Have To

Last quarter I almost shipped a product that would have died on arrival. The reason wasn't the model choice, wasn't the prompt engineering, wasn't even the budget. It was latency. I had stitched together an AI pipeline that took 2.4 seconds before a user saw a single token, and my cohort analysis from a previous launch told me exactly what that meant: 38% of users would bounce before reading the first word.

So I did what any sleep-deprived CTO does at midnight. I built a benchmark harness, pointed it at Global API's unified endpoint, and started measuring. Three weeks and roughly 4,000 API calls later, I have data I trust. Here's what I learned, what surprised me, and what I'd build differently next time.

This isn't a review. It's an architecture decision document disguised as a blog post.

Why Speed Matters More Than Most Founders Think

I've watched three different startups hemorrhage conversion rates because they treated latency as a "nice to have." In reality, time-to-first-token is the single most underrated metric in your funnel. Every additional 200ms of perceived delay measurably degrades engagement, and once you cross the 800ms threshold, users start describing your product as "slow" in support tickets — which is death by a thousand papercuts for retention.

At scale, this compounds. If you're running 10 million inference requests per month and your average TTFT is 600ms instead of 200ms, you're not just losing users. You're paying for the privilege of making them wait, because longer responses often mean more tokens billed.

That's the lens I want you to read this through. Not "which model is fastest in a vacuum," but "which model lets me ship a production-ready experience without torching my runway."

The Test Harness I Built

I ran everything through Global API's OpenAI-compatible endpoint at https://global-apis.com/v1, because I'm a strong believer in abstraction layers. If I can swap model providers with a single string change, I avoid vendor lock-in and keep my negotiating use intact when renewal time comes around.

Here's the relevant config:

Setting	What I Used
Date	May 20, 2026
Regions tested	US East (Ohio), Asia (Singapore)
Prompt	"Explain recursion in 200 words"
Average output	~150 tokens per request
Iterations	10 runs per model, mean recorded
Streaming	SSE enabled
Provider router	Global API (https://global-apis.com/v1)

I picked the recursion prompt deliberately. It's a real task that forces the model to produce structured prose, not just regurgitate a completion pattern. It also tends to expose poorly-tuned endpoints because the content has internal logical dependencies.

The Results, Ranked by My CTO Brain

Here's the full leaderboard. I sorted by tokens/sec because that's what determines throughput cost, but TTFT is right there next to it because that determines user perception.

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

A few things jump out when you look at this from a cost-per-served-request perspective rather than raw speed:

Step-3.5-Flash is the speed king at 80 tok/s, and it sits at a respectable $0.15/M output. For high-throughput UI surfaces — autocomplete, inline suggestions, streaming chat bubbles — this is the model I'd default to.

DeepSeek V4 Flash at 180ms TTFT and 60 tok/s for $0.25/M is, in my opinion, the best all three models in this whole benchmark. You get GPT-4o-class reasoning quality with sub-200ms time-to-first-token at a price that lets you serve millions of requests without sweating the invoice.

Qwen3-8B at $0.01/M is borderline absurd. At 70 tok/s and 150ms TTFT, you're looking at the cheapest production-ready model I've seen. For a classification pre-filter or simple extraction tasks, this is a no-brainer.

The bottom of the table is occupied by reasoning models. DeepSeek-R1, Kimi K2.5, and the 397B Qwen variant are slow on purpose. They spend internal compute "thinking" before emitting the first visible token. Great for agentic planning loops where you batch many decisions into one call. Terrible for chat UX.

Breaking It Down by Budget Tier

When I think about model selection for a startup, I think in tiers. Here's how I map them:

Ultra-cheap (under $0.15/M output)

Model	Speed	Price
Qwen3-8B	70 tok/s	$0.01/M
Step-3.5-Flash	80 tok/s	$0.15/M

Qwen3-8B at $0.01/M is the kind of pricing that makes me immediately ask "what's the catch?" The catch is quality. It's fine for short, structured tasks but it doesn't have the depth for nuanced generation. Use it as a pre-filter, not as your primary model.

Budget ($0.15–$0.30/M output)

Model	Speed	Price
DeepSeek V4 Flash	60 tok/s	$0.25/M
Hunyuan-TurboS	55 tok/s	$0.28/M
Qwen3-32B	45 tok/s	$0.28/M

This is the sweet spot. DeepSeek V4 Flash is my default recommendation for any new product. You get strong reasoning, fast streaming, and a price that gives you margin. Hunyuan-TurboS is a close second — if you're already getting good results from the Tencent ecosystem, stay there. Qwen3-32B trades speed for slightly better multilingual performance.

Mid-range ($0.30–$0.80/M output)

Model	Speed	Price
Doubao-Seed-Lite	50 tok/s	$0.40/M
GLM-4-32B	38 tok/s	$0.56/M
Hunyuan-Turbo	42 tok/s	$0.57/M
DeepSeek V4 Pro	30 tok/s	$0.78/M

The speed penalty here comes from larger model size. You're paying more because the model has more parameters doing more work per token. V4 Pro is where I'd draw the line — anything more expensive and you should have a quality justification.

Premium ($0.80+/M output)

Model	Speed	Price
MiniMax M2.5	28 tok/s	$1.15/M
GLM-5	25 tok/s	$1.92/M
Kimi K2.5	20 tok/s	$3.00/M

These are quality-first models. Use them when correctness matters more than user perception of speed. Code generation, legal review pipelines, anything where the output gets reviewed by a human before it ships.

The Geography Problem (And How I Solved It)

I tested from two regions because my user base is genuinely split. About 60% US, 40% Asia. Network latency from a Singapore user to a US-hosted endpoint is not free.

Model	US East TTFT	Asia TTFT	Delta
DeepSeek V4 Flash	180ms	150ms	-30ms
Qwen3-32B	250ms	210ms	-40ms
GLM-5	500ms	420ms	-80ms
Kimi K2.5	600ms	480ms	-120ms

A few observations:

Chinese-origin models (Qwen, GLM, Kimi) showed 16–20% lower TTFT from Singapore. That's not surprising — they're hosted closer to origin. If your user base is Asia-heavy, this is free latency you should capture.

DeepSeek distributes well globally. The 30ms delta between regions is essentially the speed of light difference.

The absolute worst case was Kimi K2.5 from the US at 600ms. That's not the model's fault — that's me routing a request across half the planet. With Global API, the routing layer picks the closest available cluster, but you still pay for physics.

For production-ready global products, the playbook is: route by region, keep a fallback tier for when your primary model is degraded, and measure p95 latency, not averages.

What TTFT Actually Feels Like to a User

I had a designer run synthetic user tests with me. We A/B tested the same product at four different TTFT bands. Here's what we found:

TTFT Band	What Users Said
Under 200ms	"Instant" — best UX
200–400ms	"Fast" — perfectly acceptable
400–800ms	"Noticeable delay" — complaints start
800ms+	"Slow" — bounce rate spikes

My threshold for interactive chat is 400ms TTFT. That means in my leaderboard above, the production-ready models for chat are: Step-3.5-Flash, DeepSeek V4 Flash, Hunyuan-TurboS, Qwen3-8B, Qwen3-32B, Doubao-Seed-Lite. Everything below rank 6 needs to earn its place by being demonstrably better at the task.

Code: My Production Routing Layer

Here's how I actually use this data. I run a thin router in front of Global API that picks the model based on request type, then falls back if the primary model is slow. This is the part that keeps me from getting vendor lock-in — I can change my mind about models without rewriting client code.

python
import os
import time
import httpx
from typing import Optional

BASE_URL = "https://global-apis.com/v1"
API_KEY = os.environ["GLOBAL_API_KEY"]

TIERS = {
    "ultra_fast":  {"model": "step-3.5-flash",  "fallback": "deepseek-v4-flash"},
    "balanced":    {"model": "deepseek-v4-flash", "fallback": "hunyuan-turbos"},
    "cheap":       {"model": "qwen3-8b",        "fallback": "deepseek-v4-flash"},
    "premium":     {"model": "deepseek-v4-pro",  "fallback": "minimax-m2.5"},
}

def complete(prompt: str, tier: str = "balanced", max_tokens: int = 300) -> dict:
    config = TIERS[tier]
    for attempt in (config["model"], config["fallback"]):
        start = time.perf_counter()
        try:
            resp = httpx.post(
                f"{BASE_URL}/chat/completions",
                headers={"Authorization": f"Bearer {API_KEY}"},
                json={
                    "model": attempt,
                    "messages": [{"role": "user", "content": prompt}],
                    "max_tokens": max_tokens,
                    "stream": False,
                },
                timeout=10.0,
            )
            resp.raise_for_status()
            data = resp.json()
            elapsed_ms = (time.perf_counter() - start) * 1000
            return {
                "model": attempt,
                "ttft_ms": elapsed_ms,
                "content": data["choices"][0]["message"]["content"],
            }
        except Exception as e:
            print(f"[{