Live Pinnacle odds in Node.js

npm init -y
npm install ws

export ODDSPUSH_KEY=opk_...
node feed.mjs

import WebSocket from 'ws';

const ws = new WebSocket('wss://feed.oddspush.com/v1/stream', {
  perMessageDeflate: false,
  maxPayload: 16 * 1024 * 1024,
});

ws.on('open', () => {
  ws.send(JSON.stringify({ type: 'login', token: process.env.ODDSPUSH_KEY }));
});
ws.on('message', (raw) => console.log(JSON.parse(raw.toString()))); // welcome, or an error
ws.on('close', (code) => console.log('closed', code));

{
  "type": "welcome",
  "server_time": 1793458714075,
  "feed": {"alive": true, "ready": true},
  "limits": {
    "queue_size": 1000,
    "keepalive_s": 15,
    "max_events": 1000,
    "snapshot_buffer_bytes": 4194304,
    "max_lag_s": 15
  },
  "account": {
    "id": "acme",
    "plan": "paid",
    "expires_at": 1796050714075,
    "limits": {
      "connections": 1,
      "sports": null,
      "streams": null,
      "snapshots_per_hour": 12,
      "snapshot_mb_per_hour": 400,
      "reconnects_per_minute": 12,
      "rest": true,
      "stream": true
    }
  }
}

const SUBSCRIBE = {
  type: 'subscribe',
  sports: [1],               // soccer
  channels: ['ld', 'both'],  // the displayed price; dz stays out
  snapshot: true,            // the default, spelled out
};

{
  "type": "odds",
  "data": {
    "type": "live",
    "sport_id": 1,
    "topic": "matchups/reg/sp/29/live/ld",
    "op": "upd",
    "rec": {
      "id": 1638780974,
      "parentId": 1638780960,
      "type": "matchup",
      "startTime": "2026-10-31T15:00:00Z",
      "league": {"id": 1980, "name": "England - Premier League"},
      "participants": [
        {
          "name": "Brentford",
          "alignment": "home",
          "state": {"score": 1}
        },
        {"name": "Fulham", "alignment": "away", "state": {"score": 0}}
      ],
      "state": {"minutes": 38},
      "periods": [
        {"period": 0, "status": "open"},
        {"period": 1, "status": "open"}
      ],
      "markets": [
        {
          "key": "s;0;m",
          "type": "moneyline",
          "period": 0,
          "status": "open",
          "version": 3772905262,
          "isAlternate": false,
          "prices": [
            {"designation": "home", "price": -238},
            {"designation": "away", "price": 655},
            {"designation": "draw", "price": 318}
          ],
          "limits": [{"type": "maxRiskStake", "amount": 3000}]
        },
        {
          "key": "s;0;s;-0.75",
          "type": "spread",
          "period": 0,
          "status": "open",
          "version": 3772905262,
          "isAlternate": false,
          "prices": [
            {"designation": "home", "price": -105, "points": -0.75},
            {"designation": "away", "price": -115, "points": 0.75}
          ]
        },
        {
          "key": "s;0;ou;2.5",
          "type": "total",
          "period": 0,
          "status": "open",
          "version": 3772905263,
          "isAlternate": false,
          "prices": [
            {"designation": "over", "price": 104, "points": 2.5},
            {"designation": "under", "price": -122, "points": 2.5}
          ]
        }
      ]
    },
    "ts": 1793458714075
  }
}

// book: event id -> { rec: event fields, markets: Map(key -> market), seen: Map(key -> tick), tick }
const book = new Map();
let tick = 0;            // bumped on every record applied
let sweepFrom = null;    // tick when the snapshot being served was asked for
let sweepNext = null;    // the same, for one asked while another is in flight

function applyRec(rec) {
  tick += 1;
  let ev = book.get(rec.id);
  if (!ev) {
    ev = { rec: {}, markets: new Map(), seen: new Map(), tick: 0 };
    book.set(rec.id, ev);
  }
  ev.tick = tick;
  const { markets, ...fields } = rec;
  Object.assign(ev.rec, fields);
  for (const m of markets || []) {
    const key = m.key;
    if (key === undefined) continue;
    ev.seen.set(key, tick);              // mentioned, even if not newer
    const prev = ev.markets.get(key);
    if (prev && Number.isInteger(m.version) && Number.isInteger(prev.version)
        && m.version <= prev.version) {
      continue;                          // older than what we hold: skip
    }
    if (m.status === 'open') ev.markets.set(key, m);
    else ev.markets.delete(key);         // anything but "open" closes it
  }
  const periods = Array.isArray(rec.periods) ? rec.periods : Object.values(rec.periods || {});
  for (const p of periods) {
    if (p && (p.status === 'closed' || p.status === 'settled')) {
      for (const [key, m] of ev.markets) {
        if (String(m.period) === String(p.period)) ev.markets.delete(key);
      }
    }
  }
}

// A snapshot lists only open markets: a close you missed never shows up in it.
// So note when you ask for one, and on its final part drop what nobody mentioned since.
// Call when you ask for a snapshot of everything you follow: the first subscribe on a
// connection, or a bare snapshot. Not for a later subscribe, nor for a snapshot with its
// own sports or channels: those cover a subset.
function snapshotAsked() {
  if (sweepFrom === null) sweepFrom = tick;
  else if (sweepNext === null) sweepNext = tick; // served after the one in flight
}

// On snapshot_rate_limited. It is about the next request in the order you made them, and it
// can arrive before the final part of the one still being delivered.
function snapshotRefused() {
  if (sweepNext !== null) sweepNext = null;
  else sweepFrom = null;
}

function snapshotDone() {              // on the final part
  const since = sweepFrom;
  sweepFrom = sweepNext;
  sweepNext = null;
  if (since === null) return;
  for (const [id, ev] of book) {
    if (ev.tick <= since) { book.delete(id); continue; } // not in the snapshot, no update since
    for (const key of ev.markets.keys()) {
      if ((ev.seen.get(key) ?? 0) <= since) {            // closed while we were not looking
        ev.markets.delete(key);
        ev.seen.delete(key);
      }
    }
  }
}

function onOdds(data) {
  if (data.type === 'live') {
    const rec = data.rec || {};
    if (data.op === 'del') book.delete(rec.id);
    else if (rec.id !== undefined && PRICE.test(data.topic)) applyRec(rec); // other channels pass any filter
  } else if (data.type === 'snapshot') {
    // A partial state that can arrive at any time: merge, never sweep.
    for (const rec of data.events || []) applyRec(rec);
  }
  // other data.type values: skip
}

  ws.on('close', (code) => {
    clearTimeout(silence);
    if (STOP.has(code)) {
      console.error('closed with', code, '- not reconnecting');
      process.exitCode = 1;
      return;
    }
    if (openedAt && Date.now() - openedAt > STABLE_MS) delay = BACKOFF_MIN_MS;
    const wait = Math.max(delay / 2 + Math.random() * (delay / 2), retryAfterMs);
    retryAfterMs = 0;
    delay = Math.min(delay * 2, BACKOFF_MAX_MS); // grow from the last delay, capped
    console.info('closed with', code, '- reconnecting in', Math.round(wait), 'ms');
    setTimeout(connect, wait);
  });

// American odds to decimal. Guard against a missing price first.
const toDecimal = (american) => (american > 0 ? 1 + american / 100 : 1 + 100 / -american);

toDecimal(-238); // 1.4202
toDecimal(655); // 7.55

// Node 18 or newer: fetch is built in. Save as poll.mjs.
const BASE = 'https://feed.oddspush.com/v1';
const KEY = process.env.ODDSPUSH_KEY;

async function get(path) {
  const r = await fetch(BASE + path, { headers: { 'x-token': KEY } });
  if (!r.ok) throw new Error(r.status + ' ' + path); // a 429 carries retry-after
  return r.json();
}

const { events } = await get('/events?sport_id=1'); // soccer
for (const row of events.filter((r) => r.ld || r.both).slice(0, 5)) {
  const ev = await get('/events/' + row.event_id);
  for (const [key, m] of Object.entries(ev.merged)) { // ld and both, merged by version
    console.log(ev.event_id, key, m.prices.map((x) => [x.designation, x.price]));
  }
}

Read oddspush-agent-guide.md and follow it. Build a Node.js client (ES modules, the ws package) that streams Pinnacle odds for soccer and tennis from OddsPush, keeps a correct price book, and prints every price change in decimal odds. My key is in the ODDSPUSH_KEY environment variable.