Multiplexed WebSocket

const API_KEY = "YOUR_API_KEY";
const WS_URL = `wss://therundown.io/api/v2/ws?key=${API_KEY}`;

const SUBSCRIPTIONS = [
  {
    action: "subscribe",
    id: "nba-markets",
    channel: "markets",
    params: { sport_ids: [4], market_ids: [1, 2, 3] },
  },
  {
    action: "subscribe",
    id: "nba-scores",
    channel: "scores",
    params: { sport_ids: [4] },
  },
];

function handleDelta(msg) {
  const payload = msg.data; // { meta: {...}, data: {...} }

  switch (msg.id) {
    case "nba-markets": {
      const d = payload.data;
      console.log(
        `Price: event=${d.event_id} market=${d.market_id} ${d.price} (was ${d.previous_price})`
      );
      break;
    }
    case "nba-scores":
      console.log("Score update:", payload.data);
      break;
  }
}

function connect() {
  const ws = new WebSocket(WS_URL);

  ws.onopen = () => {
    console.log("Connected — subscribing");
    // Subscriptions only live as long as the connection,
    // so re-send them on every (re)connect
    SUBSCRIPTIONS.forEach((sub) => ws.send(JSON.stringify(sub)));
  };

  ws.onmessage = (event) => {
    const msg = JSON.parse(event.data);

    if (msg.meta?.type === "heartbeat") return;

    switch (msg.type) {
      case "subscribed":
        console.log(`Subscription ${msg.id} active: ${msg.message}`);
        break;
      case "delta":
        handleDelta(msg);
        break;
      case "error":
        console.error(`Subscription error [${msg.code}]: ${msg.message}`);
        break;
      case "snapshot_error":
        console.error(`Snapshot error [${msg.code}]: ${msg.message}`);
        break;
    }
  };

  ws.onclose = () => {
    console.log("Disconnected, reconnecting in 3s...");
    setTimeout(connect, 3000);
  };

  ws.onerror = (error) => {
    console.error("WebSocket error:", error);
    ws.close();
  };
}

connect();

import asyncio
import json
import websockets

API_KEY = "YOUR_API_KEY"
WS_URL = f"wss://therundown.io/api/v2/ws?key={API_KEY}"

SUBSCRIPTIONS = [
    {
        "action": "subscribe",
        "id": "nba-markets",
        "channel": "markets",
        "params": {"sport_ids": [4], "market_ids": [1, 2, 3]},
    },
    {
        "action": "subscribe",
        "id": "nba-scores",
        "channel": "scores",
        "params": {"sport_ids": [4]},
    },
]


def handle_delta(msg):
    payload = msg["data"]  # {"meta": {...}, "data": {...}}

    if msg["id"] == "nba-markets":
        d = payload["data"]
        print(
            f"Price: event={d['event_id']} market={d['market_id']}"
            f" {d['price']} (was {d['previous_price']})"
        )
    elif msg["id"] == "nba-scores":
        print(f"Score update: {payload['data']}")


async def listen():
    while True:
        try:
            async with websockets.connect(WS_URL) as ws:
                print("Connected — subscribing")
                # Subscriptions only live as long as the connection,
                # so re-send them on every (re)connect
                for sub in SUBSCRIPTIONS:
                    await ws.send(json.dumps(sub))

                async for raw in ws:
                    msg = json.loads(raw)

                    if msg.get("meta", {}).get("type") == "heartbeat":
                        continue

                    msg_type = msg.get("type")
                    if msg_type == "subscribed":
                        print(f"Subscription {msg['id']} active: {msg['message']}")
                    elif msg_type == "delta":
                        handle_delta(msg)
                    elif msg_type == "error":
                        print(f"Subscription error [{msg['code']}]: {msg['message']}")
                    elif msg_type == "snapshot_error":
                        print(f"Snapshot error [{msg['code']}]: {msg['message']}")

        except (websockets.ConnectionClosed, ConnectionError):
            print("Disconnected, reconnecting in 3s...")
            await asyncio.sleep(3)


asyncio.run(listen())