If your Polymarket bot polls GET /book in a loop, your view of the market is as stale as your interval — and you'll lose to anyone using the WebSocket feed. This tutorial builds a real-time local order book in Python from the CLOB WebSocket stream.

Why WebSocket beats polling

• Polling: you ask every N ms → your data is up to N ms old, and you burn REST rate-limit budget.
• WebSocket: the server pushes changes → your information latency drops to roughly your network round-trip.

For a reactive strategy, this is the difference between trading the market that is and the market that was.

Connect and subscribe

import asyncio, json, websockets

WS_URL = "wss://ws-subscriptions-clob.polymarket.com/ws/market"

async def subscribe(token_ids):
    async with websockets.connect(WS_URL, ping_interval=20, ping_timeout=20) as ws:
        await ws.send(json.dumps({"assets_ids": token_ids, "type": "market"}))
        async for raw in ws:
            yield json.loads(raw)

(Confirm the exact URL, subscription payload, and message shapes against current Polymarket docs — they change.)

Maintain a local book from snapshot + deltas

The feed typically sends an initial book snapshot then incremental price-change messages. Apply them to a local structure:

class LocalBook:
    def __init__(self):
        self.bids = {}   # price -> size
        self.asks = {}

    def apply_snapshot(self, msg):
        self.bids = {float(l["price"]): float(l["size"]) for l in msg.get("bids", [])}
        self.asks = {float(l["price"]): float(l["size"]) for l in msg.get("asks", [])}

    def apply_delta(self, msg):
        for ch in msg.get("changes", []):
            side = self.bids if ch["side"] == "BUY" else self.asks
            price, size = float(ch["price"]), float(ch["size"])
            if size == 0:
                side.pop(price, None)
            else:
                side[price] = size

    def best_bid(self): return max(self.bids) if self.bids else None
    def best_ask(self): return min(self.asks) if self.asks else None
    def mid(self):
        b, a = self.best_bid(), self.best_ask()
        return (b + a) / 2 if b and a else None

Wire it together

async def run(token_id):
    book = LocalBook()
    async for msg in subscribe([token_id]):
        t = msg.get("event_type") or msg.get("type")
        if t in ("book", "snapshot"):
            book.apply_snapshot(msg)
        elif t in ("price_change", "delta"):
            book.apply_delta(msg)
        # react immediately on fresh state
        m = book.mid()
        if m is not None:
            on_mid(m, book)

asyncio.run(run(TOKEN_ID))

Measure your information lag

Always know how fresh your book is:

import time
lag_ms = (time.time() - float(msg["timestamp"])) * 1000
if lag_ms > 50:
    print(f"⚠ stale: {lag_ms:.0f}ms behind server")

The ceiling you can't code around

Here's the catch: your information latency can never beat your network round-trip to the server. The CLOB WebSocket terminates in Amsterdam — I measured ~1.2 ms from an AMS box vs ~88 ms from US-East. From the US, even a perfect WebSocket implementation is ~90 ms behind reality, because that's how long the packets take to arrive.

So the prerequisite for a fast feed is a server near the feed. I run mine on an Amsterdam-metro VPS: my Amsterdam VPS
Disclosure: affiliate link, I earn a referral. It's the box behind the 1.2 ms.

Robustness checklist

• Reconnect with backoff — WebSockets drop; resubscribe and re-snapshot on reconnect.
• Detect gaps — if deltas reference prices you don't have, request a fresh snapshot.
• Heartbeat — use ping_interval so dead connections are detected fast.
• One process, many assets — subscribe to multiple assets_ids on one socket.

Recap

WebSocket + a maintained local book gives you near-real-time perception. But the floor on "real-time" is your distance to Amsterdam. Get the server location right, then this code makes you genuinely fast.

Code is illustrative — verify against current docs. Latency from my own 2026 tests. Not financial advice.