Polymarket RTDS to PolyBolt (2026): What Changed and How to Migrate

What was Polymarket RTDS?

RTDS, the Real-Time Data Socket, launched on 24 September 2025 at wss://ws-live-data.polymarket.com. It streamed crypto prices from Binance and Chainlink, comment events and trade activity, with no authentication, a text PING every 5 seconds and messages shaped as topic, type, timestamp and payload. By the time PolyBolt arrived, it also carried Chainlink TWAP and equity price topics.

On 15 September 2026, Polymarket made RTDS legacy for reference prices. In our checks on 3 October 2026, the old socket still accepted connections and streamed Chainlink BTC/USD updates, but new price work belongs on PolyBolt.

What is PolyBolt?

PolyBolt streams reference prices over one connection, with one envelope shape for every channel:

price.crypto covers btcusd, ethusd, solusd, dogeusd, xrpusd and bnbusd, and the crypto TWAP channel adds hypeusd and zecusd. Every payload names its vendor in source, which is pyth, massive or chainlink. On the equity channels you can request chainlink or pyth with a provider filter, a feature still rolling out in late September. Polymarket's machine-readable contract also defines a public price.polymarket channel with the best bid and ask for one outcome token. It answered without credentials in our checks, but the main docs did not list it yet, so treat it as subject to change.

How do RTDS topics map to PolyBolt channels?

SDK users rename topics instead. In @polymarket/client, prices.crypto.binance and prices.crypto.chainlink become prices.crypto, prices.crypto.chainlink.twap becomes prices.crypto.twap with no windowSeconds, and prices.equity.pyth becomes prices.equity. In the Python SDK, CryptoPricesSpec, CryptoPricesChainlinkTwapSpec and EquityPricesSpec become CryptoPriceSpec, CryptoTwapPriceSpec and EquityPriceSpec. Both reject btc/usd, btcusdt and BTCUSD with a UserInputError.

What changes in authentication?

RTDS price topics were public. Every PolyBolt price channel needs CLOB API credentials, the same key, secret and passphrase used for authenticated CLOB requests, covered in Polymarket API keys explained. Send them once the socket opens and wait for authed before subscribing:

{"op":"auth","rid":"a1","auth":{"apiKey":"YOUR_API_KEY","secret":"YOUR_SECRET","passphrase":"YOUR_PASSPHRASE"}}
{"op":"authed","rid":"a1"}
{"op":"subscribe","rid":"s1","subscriptions":[{"channel":"price.crypto","filter":{"symbol":"btcusd"}}]}

A subscription sent before auth returns auth_required, and bad credentials return auth_invalid. Both leave the connection open, which is what we saw in our checks on 3 October 2026. A connection accepts at most 8 auth frames. In the SDKs, move from a public client to an authenticated SecureClient built from your signer. We type-checked the migrated TypeScript against @polymarket/client 0.11.0:

import { createSecureClient } from "@polymarket/client";
import { privateKey } from "@polymarket/client/viem";

const signer = privateKey(process.env.POLYMARKET_PRIVATE_KEY!);
const client = await createSecureClient({
  signer,
  wallet: await signer.getAddress(),
});

const stream = await client.subscribe([
  { topic: "prices.crypto.twap", symbols: ["btcusd"] },
]);

try {
  for await (const event of stream) {
    if (event.type === "subscribe") {
      console.log("snapshot", event.payload.data.length, "points");
    } else {
      console.log(event.payload.symbol, event.payload.value, event.seq);
    }
  }
} finally {
  await stream.close();
}

How do PolyBolt snapshots and sequence numbers work?

Each new subscription gets an acknowledgement and one frame flagged snapshot: true, holding the previous two minutes of prices in payload.data, or an empty array when nothing recent exists. RTDS sent nothing for a quiet symbol. Seed your state from the snapshot, then apply live updates. Repeating a channel and filter you already hold returns another acknowledgement but no new snapshot.

Data frames carry v, channel, seq, ts and payload, with symbol, value, full_accuracy_value, timestamp and source inside. seq is consecutive per connection and per channel, including snapshots, and resets on reconnect. dropped, when present, counts frames skipped because your client fell behind. Read full_accuracy_value, an exact decimal string, rather than the float value. Legacy TWAP frames used window_s and an E18 fixed-point price, and in our checks the legacy Chainlink spot topic sent E18 integers too, so delete any E18 conversion.

What are PolyBolt's connection limits and close codes?

The text PING is gone. The server pings every 25 seconds, standard clients answer automatically, and two missed pongs close the socket with 4002. You can still send {"op":"ping"} and get pong back. Close 4003 means the server is draining, so reconnect once after a random 0 to 10 seconds. 4008 is a policy violation to fix, 4001 is an authentication failure, and 1006 calls for exponential backoff with full jitter from 1 to 30 seconds. After any reconnect, authenticate again, resubscribe with any provider pins and re-read source.

This raw client authenticates, subscribes to spot and TWAP prices and handles the new envelope, in Node 22 or newer. We ran it with placeholder keys and got the expected auth_invalid:

const ws = new WebSocket('wss://ws-live-v2.polymarket.com/ws');

const subscriptions = [
  { channel: 'price.crypto', filter: { symbol: 'btcusd' } },
  { channel: 'price.crypto.twap', filter: { symbol: 'btcusd', window_seconds: 60 } },
];

ws.addEventListener('open', () => {
  ws.send(JSON.stringify({
    op: 'auth',
    rid: 'a1',
    auth: { apiKey: 'YOUR_API_KEY', secret: 'YOUR_SECRET', passphrase: 'YOUR_PASSPHRASE' },
  }));
});

ws.addEventListener('message', (event) => {
  const msg = JSON.parse(event.data);
  if (msg.op === 'authed') {
    ws.send(JSON.stringify({ op: 'subscribe', rid: 's1', subscriptions }));
  } else if (msg.op === 'error') {
    console.error('error', msg.code, msg.channel ?? '');
  } else if (msg.v === 1) {
    if (msg.dropped) console.warn(msg.dropped, 'frames dropped on', msg.channel);
    if (msg.snapshot) {
      console.log('snapshot', msg.channel, msg.payload.data.length, 'points');
    } else {
      console.log(msg.channel, msg.seq, msg.payload.full_accuracy_value, msg.payload.source);
    }
  }
});

ws.addEventListener('close', (event) => console.log('closed', event.code));

What is the RTDS to PolyBolt timeline?

Two RTDS streams do not move. Trade activity stays on RTDS because it has no PolyBolt channel. The live comments stream stays for now but is being retired without a streaming replacement, so list comments with Gamma's GET /comments. Order book and user streams run on the separate CLOB WebSocket, which PolyBolt does not replace, covered in the Polymarket WebSocket API guide.

What is the migration checklist?

1. Upgrade to @polymarket/client or polymarket-client 0.11.0 or later, or point raw clients at wss://ws-live-v2.polymarket.com/ws and delete the PING heartbeat.
2. Load CLOB API credentials and send {"op":"auth"} before any price subscription.
3. Rewrite subscribe frames to op, channel and a filter object, and batch them per connection.
4. Rename crypto symbols to lowercase USD pairs such as btcusd, and lowercase equity symbols.
5. Check feeds that change: Binance users get Chainlink USD prices, and 30-second TWAP users need another source.
6. Seed state from the snapshot, read full_accuracy_value and source, and watch dropped.
7. Stay at or below 64 subscriptions per connection.
8. Handle 4003 with one jittered reconnect and 4008 as a bug, then re-authenticate and resubscribe after every reconnect.

If your bot leaned on RTDS's Binance feed next to market data, the Predictefy API streams Binance and Chainlink reference price feeds alongside order books from Polymarket and 15+ other venues.

Frequently Asked Questions