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.
0steps
Diagnosis checklist steps
Critical metrics and considerations to track
0%
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

network monitoring dashboard screen
Photo by Tima Miroshnichenko from Pexels

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
A healthy TTFB is < 500 ms for US regions and < 1000 ms for distant regions (Asia, Middle East). If TTFB exceeds 2 seconds, either OpenRouter is overloaded, your network path is congested, or you're routing through an extra hop.

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.

  1. 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
   
  1. 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.
  1. Make a raw HTTP request outside your application. Use curl or 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"}]}'
   
  1. Check your network path. Use traceroute (Unix) or tracert (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

cloud infrastructure operations
Photo by Nothing Ahead from Pexels

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:

  1. 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.
  1. Calculate the median and 95th percentile for each metric. Discard outliers (e.g., requests that timeout entirely).
  1. 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:

  1. Visit OpenRouter's status page (typically linked from their main site or /status endpoint).
  2. Check for active incidents affecting your region, model, or the provider behind the model (e.g., if OpenRouter routes Claude requests to Anthropic).
  3. Review the incident timeline. If OpenRouter had downtime 30 minutes ago and your latency spike occurred then, correlation is high.
  4. 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.

  1. Log into your OpenRouter dashboard. Check your account tier, remaining balance, and any warnings about usage.
  2. 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.
  3. Confirm payment method is current. Some platforms soft-throttle accounts with expired or invalid payment info as a retention signal.
  4. 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

developer checking api metrics
Photo by Jakub Zerdzicki from Pexels

OpenRouter's performance varies significantly by region due to geographic routing, CDN edges, and backbone congestion.

When OpenRouter Is Slow: Diagnosis Checklist process
Figure 1: When OpenRouter Is Slow: Diagnosis Checklist at a glance.

Multi-region diagnostic checklist

RegionTTFB (ms)TTFT (ms)StatusAction
US East3202100βœ“ Normal,
US West3502150βœ“ Normal,
Europe (Frankfurt)12002800⚠ SlowCheck Frankfurt backbone congestion or Anthropic EU routing
Asia (Singapore)21003500βœ— CriticalMay indicate routing via US; consider regional failover model
If only one region is slow:
  • 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.
If all regions are slow:
  • 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

  1. 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.
  1. 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.
  1. 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.
  1. DNS resolution delays. The first request to openrouter.io might take 100–500 ms just to resolve the IP. Cache DNS or use a faster resolver (e.g., Cloudflare's 1.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.
Quick test: Call OpenRouter asynchronously and measure the time from your request submission to the first network packet being sent (not received). If that time is high, your app is the bottleneck, not OpenRouter.

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

TTFB (Time to First Byte) is the latency from submitting your request to OpenRouter to receiving the first response byte. It reflects network delay and OpenRouter's queue depth. TTFT (Time to First Token) includes TTFB plus the model's time to generate the first token of the response. A slow TTFB but normal TTFT means OpenRouter is queueing; a slow TTFT means the model itself is slow or overloaded.
Test the same request using raw HTTP (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.
US regions typically see 300–600 ms TTFB and 1.5–3 seconds TTFT for chat models. EU regions see 800–1500 ms TTFB and 2–4 seconds TTFT. Asia and other distant regions see 1.5–3 seconds TTFB and 3–6 seconds TTFT. These are medians; the 95th percentile is usually 1.5–2Γ— higher. Establish a 7-day baseline for your region and model to set realistic SLOs.
First confirm OpenRouter is the bottleneck using the diagnosis steps (raw HTTP, baseline comparison, etc.). If confirmed, test a direct call to OpenAI or Anthropic from the same region. Often the issue is a specific provider's regional routing, not OpenRouter's infrastructure. If OpenRouter consistently underperforms in your region, regional failover or provider diversification is justified.

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.

Yes. Observinio monitors OpenRouter and OpenAI from 21 global regions daily, tracking TTFB, TTFT, and error rates. Degradation alerts notify you the moment latency spikes beyond your baseline. A weekly summary email shows regional trends and provider comparisons, eliminating manual baseline tracking. For teams running production LLM services, this removes the guesswork and cuts incident response time significantly.

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