Photo by Bulat843 π from Pexels
OpenRouter slowness feels invisible until it isn't. A chat feature that took 800 ms yesterday now takes 4 seconds. Your users notice. Your support team gets pinged. But where did the delay originate, at OpenRouter's infrastructure, your routing layer, or somewhere in between?
This checklist walks you through the diagnosis methodically, separating signal from noise using concrete latency metrics: time to first byte (TTFB), time to first token (TTFT), regional variance, and provider baseline comparisons.
TL;DR
- Distinguish TTFB from TTFT: TTFB tells you if OpenRouter accepted your request; TTFT tells you if the model is responding. Both matter, and they fail differently.
- Check regional latency: OpenRouter performance varies 2β5Γ across regions. If only Europe is slow, the problem is likely regional routing or provider capacity, not your code.
- Verify baseline vs degradation: Compare today's latency to your 7-day rolling average using daily probes. A 30 % spike is a flag; a 300 % spike is an incident.
- Isolate your stack from the provider: Run a synthetic request directly from your region to OpenRouter. If it's slow there, OpenRouter is the bottleneck. If it's fast there but slow in your app, debug your code path.
- Check OpenRouter's public status and your billing state: Free trials and rate-limited accounts see artificial slowness; provider outages affect everyone the same way.
Key takeaway: Separate time-to-first-byte (TTFB) from time-to-first-token (TTFT) measurements, establish a 7-day regional baseline, and systematically eliminate variables using raw HTTP testingβthis transforms OpenRouter slowness diagnosis from guesswork into reproducible, data-driven troubleshooting.
The Two Latency Metrics You Must Know
Most slowness complaints conflate two different measurements. Separating them is your first diagnostic win.
Time to First Byte (TTFB)
TTFB measures the round-trip from your request submission to OpenRouter's first response byte. It includes:
- Network latency (your region to OpenRouter's endpoint)
- OpenRouter's request queue and validation
- Initial model load or routing decision
Time to First Token (TTFT)
TTFT measures the time from your request submission to the first token of the response stream. It includes TTFB plus the model's actual thinking time.
TTFT is typically 1β5 seconds for fast models (GPT-4o, Claude 3.5 Sonnet) on lightweight prompts, and 5β15 seconds for longer contexts or reasoning models. TTFT is where you'll notice model-level performance differences.
Why the distinction matters: If TTFB is slow but TTFT is reasonable, OpenRouter is queueing requests but serving them normally once started. If both are slow, either OpenRouter is resource-constrained or your network is the bottleneck.
Step 1: Confirm the Slowness Is Real
Before diving into vendor blame, rule out local noise.
- Log exact timestamps and durations in your application code. Measure from the moment you call OpenRouter's API to the moment you receive the first byte (TTFB) and the first token (TTFT). Use millisecond precision.
start_time = time.time()
response = requests.post("https://openrouter.io/api/v1/chat/completions", ...)
ttfb = (time.time() - start_time) 1000 # milliseconds
# Optionally: capture first-token timestamp from stream callbacks
- Test from multiple regions. If you have CI/CD runners or edge functions in different regions, trigger the same request from each and log latency. This immediately reveals whether slowness is global or regional.
- Make a raw HTTP request outside your application. Use
curlor Postman to isolate your app's client library, retry logic, or connection pooling from the actual API round-trip:
curl -w "@curl-format.txt" -o /dev/null -s https://openrouter.io/api/v1/chat/completions \
-H "Authorization: Bearer YOUR_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"openai/gpt-4o","messages":[{"role":"user","content":"hi"}]}'
- Check your network path. Use
traceroute(Unix) ortracert(Windows) to OpenRouter's endpoint. Unexpected hops or timeouts suggest routing issues on your ISP or cloud provider's side, not OpenRouter.
Step 2: Compare Against Your Baseline
Absolute latency numbers are meaningless without context. A 2-second TTFB might be normal for your Tokyo office but a red flag for New York.
Establish a 7-day rolling baseline
For each region where you route traffic:
- Record TTFB and TTFT daily using the same prompt, model, and request parameters. Observinio's daily probes automate this; if you're self-monitoring, run a cron job every 6β12 hours.
- Calculate the median and 95th percentile for each metric. Discard outliers (e.g., requests that timeout entirely).
- Watch for drift. A 10 % increase day-over-day is noise. A 30 % sustained increase over 3 days is a signal. A 200 % spike within an hour is an incident.
Example baseline tracking
Region: us-east-1
Date: 2024-11-13
TTFB (median): 320 ms
TTFB (p95): 680 ms
TTFT (median): 2100 ms
TTFT (p95): 3200 ms
Date: 2024-11-14
TTFB (median): 310 ms
TTFB (p95): 670 ms
TTFT (median): 2150 ms
TTFT (p95): 3300 ms
β Stable (within Β±5%).
Date: 2024-11-15
TTFB (median): 890 ms (β179 % vs 7-day avg of 315 ms)
TTFB (p95): 2100 ms
TTFT (median): 2200 ms
TTFT (p95): 3500 ms
β Alert: TTFB degradation in this region.
If your baseline is trending upward gradually, you may be hitting rate limits or your account is throttled. If it spikes suddenly, investigate provider incidents or network issues.
Step 3: Check the Provider Status Page
OpenRouter publishes real-time status at their official channels. Before escalating internally:
- Visit OpenRouter's status page (typically linked from their main site or
/statusendpoint). - Check for active incidents affecting your region, model, or the provider behind the model (e.g., if OpenRouter routes Claude requests to Anthropic).
- Review the incident timeline. If OpenRouter had downtime 30 minutes ago and your latency spike occurred then, correlation is high.
- Cross-reference with your logs. Did error rates or token rejections spike at the same time? That's stronger evidence.
"The API provider verification checklist adds routing and billing evidence.">, OpenRouter requests time out: find where the request stops*
Step 4: Verify Your Billing and Account Status
Free trials and rate-limited accounts experience artificial slowness as built-in throttling.
- Log into your OpenRouter dashboard. Check your account tier, remaining balance, and any warnings about usage.
- Review rate limits. If you're near your per-minute or per-day cap, requests queue behind earlier ones. This manifests as high TTFB even if the provider is healthy.
- Confirm payment method is current. Some platforms soft-throttle accounts with expired or invalid payment info as a retention signal.
- Check for abuse flags. If your account triggered OpenRouter's abuse detection (e.g., too many simultaneous requests, request patterns that look like a scraper), you may be silently rate-limited.
Step 5: Isolate Regional vs. Global Issues
OpenRouter's performance varies significantly by region due to geographic routing, CDN edges, and backbone congestion.
Multi-region diagnostic checklist
| Region | TTFB (ms) | TTFT (ms) | Status | Action |
|---|---|---|---|---|
| US East | 320 | 2100 | β Normal | , |
| US West | 350 | 2150 | β Normal | , |
| Europe (Frankfurt) | 1200 | 2800 | β Slow | Check Frankfurt backbone congestion or Anthropic EU routing |
| Asia (Singapore) | 2100 | 3500 | β Critical | May indicate routing via US; consider regional failover model |
- Check that region's ISP or cloud provider status pages. A DDoS or fiber cut on the backbone affects all traffic, not just OpenRouter.
- Test a different model or provider from the same region. If OpenAI is fast but OpenRouter is slow from Frankfurt, the issue is OpenRouter's EU endpoint or its routing decision for that region.
- Measure the network path with
mtr(My Traceroute on Unix) to see packet loss or high latency at specific hops.
- OpenRouter likely has a global incident or capacity crunch. Check their public status page.
- Contact OpenRouter support with your baseline latency data and the exact timestamps of the degradation.
Step 6: Debug Your Application Layer
Assume OpenRouter's latency is acceptable (confirmed via the steps above). If you're still seeing slow requests, the problem is in your code or infrastructure.
Common culprits
- Connection pooling not enabled. HTTP connection setup (TLS handshake, TCP 3-way) adds 100β500 ms per request. Use persistent connections or connection pools in your HTTP client.
- Retries with exponential backoff. A single retry with a 1-second backoff can double your perceived latency. Check if your client library or middleware is retrying silently.
- Synchronous code blocking your request thread. If your web server runs a single thread per request, a slow database query before calling OpenRouter will inflate TTFB in your logs, even though OpenRouter itself is fast.
- DNS resolution delays. The first request to
openrouter.iomight take 100β500 ms just to resolve the IP. Cache DNS or use a faster resolver (e.g., Cloudflare's 1.1.1.1).
- Rate limiting or queuing in your application. If you're queuing requests client-side (e.g., to avoid overloading your backend), that queue delay is included in your TTFB measurement.
Diagnosis Checklist: Quick Reference
Your progress is saved automatically in your browser.
When to Escalate to OpenRouter Support
If you've completed the checklist and the problem persists:
- Provide precise data:
- TTFB and TTFT (median and p95) for the last 7 days in affected region(s).
- The exact timestamp(s) of the degradation.
- Your account ID and the model(s) affected.
- A single raw HTTP request that reproduces the slowness (sanitize the API key).
- Include evidence of elimination:
- Latency is slow from your infrastructure, not just in your app.
- It's slow across multiple models or endpoints.
- It began after a specific date/event or occurred during a known OpenRouter incident window.
- Ask for specifics:
- Is your account rate-limited or flagged?
- Is there a routing or capacity issue affecting your region?
- Is the backend model (Anthropic, OpenAI, etc.) experiencing issues?
FAQ
Frequently Asked Questions
curl) outside your application, measuring network round-trip time. If curl is fast but your application is slow, the issue is in your code or infrastructure (connection pooling, retries, DNS, or queuing). If both are slow, OpenRouter or your network path is the culprit. Compare results across regions to isolate geography from provider issues.Pro Tip: Regional Failover Strategy
When diagnosing regional slowness, run your diagnostic checklist in parallel across at least three providers (OpenRouter, OpenAI, Anthropic) from your target region. This reveals whether the issue is provider-specific, region-specific, or global. Use this data to build a rational failover routing policy that prioritizes the fastest provider by region, ensuring your users always get the best latency regardless of which backend is experiencing degradation.
Stay Ahead of Slowness with Observinio
Latency diagnosis is reactive by nature, you respond after users complain. Observinio flips the script: daily synthetic probes from 21 regions establish your baseline automatically, and email alerts fire the moment degradation crosses your threshold. You'll know OpenRouter is slow before support tickets arrive.
For teams shipping AI features in production, set up Observinio to monitor your OpenRouter and OpenAI endpoints, compare regional variance, and get weekly latency summaries in your inbox. It's the fastest way to transform reactive troubleshooting into proactive reliability.
Additional Resources
- OpenRouter requests time out: find where the request stops - When an OpenRouter request times out, first identify whether it failed before connection, before the first response, or during streaming.
- OpenRouter Auth Errors Explained: 401 Causes and Fixes - The most common concrete cause is an expired API key, because OpenRouter returns "User not found" rather than a key-expired message once a key ...
- How to Evaluate LLM Provider Performance - One provider may return the first token quickly, but slow down during the rest of the response. ... A 5-step provider evaluation checklist.
