Fastest Polymarket data API, live freshness across Mobula and Codex
Per event delay between provider arrival and Polymarket gateway publish, measured every minute on the top markets by 24 hour volume.
Prediction markets generate the most time sensitive event stream in crypto. An election market settles in seconds, a sports book moves on every play. Builders that integrate Polymarket through a data provider rather than hitting the CLOB directly need to know how many milliseconds that provider adds between when Polymarket itself publishes a trade and when the provider relays the same trade to its WebSocket subscribers. This benchmark measures exactly that. The harness subscribes to the same basket of top volume Polymarket markets on Polymarket's own CLOB WebSocket (the canonical source, T0), on Mobula's PM WebSocket, and on Codex GraphQL subscriptions. Each trade is cross correlated by condition id and price across the three streams, and the per provider lag versus Polymarket's gateway publish time is recorded as a Prometheus histogram. The leaderboard sorts by p50 freshness delta in milliseconds, lower is better.
Methodology
Three WebSocket subscribers ride the same rotating basket of ~20 top volume Polymarket markets simultaneously. For every trade event published on Polymarket's own CLOB WebSocket gateway (the canonical T0), we record the moment it lands and the moment each provider relays the same trade. The signature used to match a trade across providers is the tuple (conditionId, priceUSD rounded to 3 decimals, trade size, 5 second time bucket), which is robust against the minor clock skew between gateways. Providers that fail to relay a trade within 90 seconds are not counted toward their p50, only toward their receive total, so a provider can look fresh on the leaderboard while silently dropping events. The success rate column flags that.
Frequently asked
Which Polymarket data API has the lowest latency right now?
Polymarket currently leads at 1 ms (p50 over the last 24h) measured as time from Polymarket's own CLOB WebSocket publish to provider relay. The leaderboard re sorts every minute on fresh Prometheus samples, so the answer reflects the actual measured lag on the active market basket, not a marketing claim.
What does 'freshness delta' mean for a prediction market API?
We connect to Polymarket's own CLOB WebSocket and to the provider's WebSocket simultaneously, subscribe to the same markets, and for every trade event we record how many milliseconds the provider takes to relay the event after Polymarket itself publishes it. Lower is better. Polymarket's own gateway publish time is the canonical T0 because by construction nothing downstream can be faster than the source.
Is Mobula's PM WebSocket faster than Codex?
It depends on what each provider does under the hood. Mobula is an edge cached relay of Polymarket's own gateway, so the p50 delta is roughly the network round trip between the two gateways plus a few ms of bookkeeping. Codex ingests the on chain confirmation on Polygon, which adds the block time (~2 seconds) before any trade can be relayed. For a live UI building on Polymarket, the relay path wins on freshness. For on chain reconciliation or settlement workflows, the chain indexed path is what you actually want. They answer different questions.
Why don't you include Polymarket REST polling on this benchmark?
Freshness is a WebSocket question. REST polling at 1s would have a floor freshness around 500ms (poll interval / 2) plus RTT, dominated by how often you poll. The Polymarket gateway WebSocket exists for exactly this reason, to avoid that floor. Adding REST as a row would make the leaderboard noisy without changing the conclusion: WebSocket beats polling by definition for real time data.
Are these numbers comparable to Kalshi or Limitless?
Not directly. This benchmark measures Polymarket as the underlying venue, since it's the largest and the one most providers proxy. Kalshi and Limitless are separate exchanges with separate data feeds, and providers that cover them often have a different ingestion path. We may add a Kalshi specific tab in a later phase. For now, treat the leaderboard as 'how fresh is your Polymarket data feed'.
How does OpenChainBench measure freshness?
Three WebSocket clients run in parallel inside the harness, all subscribed to the same basket of top volume Polymarket markets. Every minute we refresh the basket from `gamma-api.polymarket.com`. For each trade event, we compute a signature `(conditionId, price rounded to 3 decimals, size in micros, 5 second time bucket)` and record the wall clock receive time on each provider. The freshness delta is `recv_provider - recv_polymarket` for the same signature. We export the histogram to Prometheus, the leaderboard reads the 24h p50.
Source code github.com/MobulaFi/mobula-monorepo/tree/main/miniapps/pm-freshness-bench
