I Benchmarked 15 AI Models for Speed – Here's What Will Blow Your Mind

So I’m building this little chat app. Nothing fancy, just a side project that might turn into something real. And you know what? Speed was killing me. Not the code – the latency. Every time a user hit send and waited, I could see them bouncing. 100ms extra? Bye bye user. I needed to KNOW which models were actually fast, not just the ones with flashy marketing.

So I did what any indie hacker would do: I spent a weekend benchmarking 15 different models through Global API. I ran them from two regions, measured Time to First Token (TTFT) and tokens per second. And I’m sharing it all here, raw and unfiltered.

TL;DR: DeepSeek V4 Flash is the all-round beast (~60 tok/s, ~180ms TTFT). Step-3.5-Flash is the speed demon at ~80 tok/s. And if you're broke but need speed? Qwen3-8B – $0.01/M output and 70 tok/s. I'm not even joking.

How I Ran the Tests

I wanted real-world results, not some synthetic benchmark. So I used a simple prompt: "Explain recursion in 200 words." Streamed via SSE. Each model got 10 runs, averaged. Heres the setup:

Here's the Python code I used to measure – feel free to steal it:

import time
import requests
import json

def benchmark_model(model, api_key):
    url = "https://global-apis.com/v1/chat/completions"
    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
    payload = {
        "model": model,
        "messages": [{"role": "user", "content": "Explain recursion in 200 words."}],
        "stream": True
    }

    start = time.time()
    response = requests.post(url, json=payload, headers=headers, stream=True)
    first_token_time = None
    tokens = []

    for line in response.iter_lines():
        if line:
            if line.startswith(b"data: ") and line[6:] != b"[DONE]":
                if first_token_time is None:
                    first_token_time = time.time()
                tokens.append(json.loads(line[6:]))

    end = time.time()
    ttft = (first_token_time - start) * 1000  # ms
    elapsed = end - start
    tok_per_sec = len(tokens) / elapsed
    return ttft, tok_per_sec

api_key = "your-api-key-here"
# Example: DeepSeek V4 Flash
ttft, tps = benchmark_model("deepseek-v4-flash", api_key)
print(f"TTFT: {ttft:.0f}ms | Tokens/s: {tps:.1f}")

Super simple. You can drop any model name from Global API's list.

The Speed Ranking (Fastest to Slowest)

Honestly, I was shocked by some of these results. I’ve put them in a table because I’m a data nerd, but I’ll break it down after.

Note: Reasoning models (R1, K2.5) include internal thinking time before first token – that's why TTFT is high. But they're smart.

Speed by Price Tier

Because let's be real – as an indie hacker, I care about speed AND cost. Can't be spending $3 per million tokens on a hobby project.

Ultra-Budget (< $0.15/M)

Qwen3-8B is INSANE. 70 tok/s at literally ONE CENT per million output tokens. For simple stuff – summarization, classification, chatbots that don't need deep reasoning – it's unbeatable. Step-3.5-Flash is the speed king at 80 tok/s, and only $0.15/M. Worth it if you need low latency.

Budget ($0.15–$0.30/M)

This is the sweet spot. DeepSeek V4 Flash is my go-to. 60 tok/s, 180ms TTFT, and quality that rivals GPT-4o. For $0.25/M. I mean... just use it.

Mid-Range ($0.30–$0.80/M)

These are bigger models, so speed drops. DeepSeek V4 Pro at 30 tok/s is still decent, but you pay more for quality. Honestly, unless you need the extra reasoning, stick with V4 Flash.

Premium ($0.80+/M)

These are for when correctness > speed. Like legal document analysis or code generation where a mistake costs you. But at 20 tok/s? Your users will feel it. Use only if you have to.

Geographic Latency: Where You Run Matters

I tested from two regions to see the network impact. You'd be surprised how much server location matters.

Asian models like Qwen and Kimi are 16-20% faster from Asia. Obvious, right? But DeepSeek V4 Flash is almost the same everywhere – great global distribution. If your users are in Asia, consider Qwen3 models or DeepSeek.

Real-World Impact: TTFT Tells the Story

I built a little chart for myself (sharing it here because why not):

My recommendation: Keep TTFT under 400ms for interactive chat. Use DeepSeek V4 Flash (180ms) or Qwen3-8B (150ms) or Step-3.5-Flash (120ms). Your users will thank you.

The Bottom Line

If you're an indie hacker like me, don't overthink this. For most use cases:

• Need speed + quality? DeepSeek V4 Flash. (60 tok/s, $0.25/M)
• Need raw speed on a budget? Qwen3-8B. (70 tok/s, $0.01/M)
• Need to flex with the fastest? Step-3.5-Flash. (80 tok/s, $0.15/M)
• Building a reasoning app? Accept slower TTFT – R1 or K2.5.

I tested all through Global API – they just give you a single endpoint (https://global-apis.com/v1) and you swap model names. Super easy. If you want to run these benchmarks yourself (and you should, because your use case might differ), grab an API key