I Measured Polymarket's API Latency From 5 Regions — Here's the Script and the Results

TL;DR — I benchmarked round-trip latency to Polymarket's CLOB order API (clob.polymarket.com) from five VPS regions. Amsterdam: ~1.2 ms. US-East: ~88 ms. The script is below — run it yourself.

If you build trading bots, you eventually ask: where is the order book I'm racing other bots to hit? For Polymarket, every Reddit answer is a guess and nobody posts numbers. So I measured it.

Why latency to the order book matters

Polymarket runs an off-chain Central Limit Order Book (CLOB) that matches orders, then settles on Polygon. When a market moves, bots race to the same fill — and your round-trip time to the CLOB is, mechanically, your place in line. Code optimization is rounding error next to physical distance to the endpoint.

The benchmark script

ICMP ping lies behind CDNs, so I measure the TCP connect and time-to-first-byte on a real HTTPS request — far more honest for a web service.

import socket, ssl, time, statistics, http.client

HOST = "clob.polymarket.com"
N = 100

def tcp_connect_ms():
    start = time.perf_counter()
    s = socket.create_connection((HOST, 443), timeout=5)
    dt = (time.perf_counter() - start) * 1000
    s.close()
    return dt

def ttfb_ms():
    ctx = ssl.create_default_context()
    start = time.perf_counter()
    conn = http.client.HTTPSConnection(HOST, 443, timeout=5, context=ctx)
    conn.request("GET", "/")
    resp = conn.getresponse()
    resp.read(1)                       # first byte
    dt = (time.perf_counter() - start) * 1000
    conn.close()
    return dt

def bench(fn, n=N):
    xs = sorted(fn() for _ in range(n))
    return {
        "p50": round(statistics.median(xs), 2),
        "p99": round(xs[int(n * 0.99) - 1], 2),
        "min": round(xs[0], 2),
    }

print("TCP connect:", bench(tcp_connect_ms))
print("TTFB       :", bench(ttfb_ms))

Run it on whatever box you've got, then on a box in another region, and compare. That delta is the whole story.

The results

VPS region	ICMP ping (p50)	TCP connect (p50)	TTFB (p50)
Amsterdam (AMS)	~1.2 ms	~1.4 ms	~6 ms
Frankfurt	~8 ms	~9 ms	~16 ms
London	~10 ms	~11 ms	~19 ms
US-East (Virginia)	~88 ms	~90 ms	~110 ms
Singapore	~165 ms	~168 ms	~195 ms

What the 1.2 ms means (and what it doesn't)

A 1.2 ms round trip is near-LAN. Light in fiber covers ~200 km per millisecond round-trip, so 1.2 ms means the endpoint is within ~100 km of my Amsterdam box. Across the Atlantic it's physically impossible — hence US-East's ~88 ms.

Being precise about the claim:

• ✅ Proven: the CLOB order API's point of presence is in Amsterdam.
• 🤔 Inferred: that the matching engine itself is co-located (the ~6 ms TTFB on order-book requests is consistent with local matching, but I can't see inside their stack).

Either way the actionable conclusion is identical: to minimize latency to Polymarket, host in Amsterdam. US-East — the most common guess — is ~90 ms slower, which no code change recovers.

What I run

My bot lives on a modest VPS in a real Amsterdam-metro datacenter — that's what produces the 1.2 ms. Specs barely matter (a Polymarket bot is network-bound, not CPU-bound); the city is the entire trick. A "Europe" box that actually sits in Frankfurt costs ~8 ms instead.

The provider/plan I use: HostKey — Amsterdam VPS/dedicated

Disclosure: that's an affiliate link — I earn a referral if you sign up. I pay for and use the same box; the 1.2 ms above is from it.

Try it

Spin up an hourly box in Amsterdam and one in US-East, run the script on both, and watch the ~90 ms gap. If a region labeled "EU" pings >5 ms, it isn't really in Amsterdam — that's your proof to look elsewhere.

Numbers are from my own 2026 tests and will drift as Polymarket scales. Re-measure before betting money on it. Not financial advice.

---

If this was useful, I'm writing more on building low-latency Polymarket bots in Python — follow along.