Quickstart

import asyncio

from parlayx.stream import StreamClient


async def main():
    # A local book we keep in sync from snapshot + delta frames.
    bids: dict[float, float] = {}
    asks: dict[float, float] = {}

    async with StreamClient() as stream:
        # Subscribe. The `BOOK` channel is the default, so `channels` is optional.
        await stream.subscribe([{"venue": "POLYMARKET", "tokenId": "71045620195867637"}])

        async for frame in stream:
            if frame.type == "SNAPSHOT":
                # The full book state. Arrives once per subscription, before any deltas.
                bids = {level.price: level.size for level in frame.bids}
                asks = {level.price: level.size for level in frame.asks}
                print(f"snapshot seq={frame.seq}: {len(bids)} bids / {len(asks)} asks")
            elif frame.type == "DELTA":
                # size 0 deletes the level; anything else sets it.
                for change in frame.changes:
                    side = bids if change.side == "BID" else asks
                    if change.size == 0:
                        side.pop(change.price, None)
                    else:
                        side[change.price] = change.size


asyncio.run(main())

import { createStreamClient } from "@parlayx/sdk/stream";

const stream = createStreamClient({
  keyId: process.env.PARLAYX_KEY_ID!,
  privateKeyHex: process.env.PARLAYX_PRIVATE_KEY_HEX!,
});

/* A local book we keep in sync from snapshot + delta frames. */
const book = { bids: new Map<number, number>(), asks: new Map<number, number>() };

/* The full book state. Arrives once per subscription, before any deltas. */
stream.on("SNAPSHOT", (frame) => {
  book.bids = new Map(frame.bids.map((l) => [l.price, l.size]));
  book.asks = new Map(frame.asks.map((l) => [l.price, l.size]));
  console.log(`snapshot seq=${frame.seq}: ${book.bids.size} bids / ${book.asks.size} asks`);
});

/* Incremental changes. size 0 deletes the level; anything else sets it. */
stream.on("DELTA", (frame) => {
  for (const change of frame.changes) {
    const side = change.side === "BID" ? book.bids : book.asks;
    if (change.size === 0) side.delete(change.price);
    else side.set(change.price, change.size);
  }
});

/* Subscribe. The `BOOK` channel is the default, so `channels` is optional. */
stream.subscribe([{ venue: "POLYMARKET", tokenId: "71045620195867637" }]);

subscription_id = None

async with StreamClient() as stream:
    await stream.subscribe([{"venue": "POLYMARKET", "tokenId": "71045620195867637"}])

    async for frame in stream:
        if frame.type == "SUBSCRIBED":
            subscription_id = frame.subscription_id
            print(f"subscribed {frame.subscription_id} ({frame.channel})")
            break

    if subscription_id:
        await stream.unsubscribe([subscription_id])
# `async with` closes the socket and stops reconnecting.

let subscriptionId: string | undefined;

stream.on("SUBSCRIBED", (frame) => {
  subscriptionId = frame.subscriptionId;
  console.log(`subscribed ${frame.subscriptionId} (${frame.channel})`);
});

/* later... */
if (subscriptionId) stream.unsubscribe([subscriptionId]);
stream.close(); /* closes the socket and stops reconnecting */

stream = StreamClient(
    base_url="wss://wss.parlayx.com",  # override the origin; path is always /v1/orderbook
    on_reconnecting=lambda event: print("reconnecting, attempt", event.attempt),
    on_terminated=lambda event: print("stream stopped:", event.reason),
    on_unparseable=lambda raw: print("dropped an unrecognised frame:", raw),
)

import WebSocket from "ws";

const stream = createStreamClient({
  keyId: process.env.PARLAYX_KEY_ID!,
  privateKeyHex: process.env.PARLAYX_PRIVATE_KEY_HEX!,
  baseUrl: "wss://wss.parlayx.com", /* override the origin; path is always /v1/orderbook */
  WebSocket, /* inject a WebSocket implementation for tests or Node.js older than 22 */
});