Live Pinnacle odds in Python

pip install "websockets>=13"

export ODDSPUSH_KEY=opk_...
python feed.py

import asyncio
import json
import os

from websockets.asyncio.client import connect

URL = "wss://feed.oddspush.com/v1/stream"
KEY = os.environ["ODDSPUSH_KEY"]  # opk_ and 43 characters


async def main() -> None:
    async with connect(URL, compression=None, max_size=16 * 2**20) as ws:
        await ws.send(json.dumps({"type": "login", "token": KEY}))
        print(json.loads(await ws.recv()))  # welcome, or an error and then a close


asyncio.run(main())

{
  "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
    }
  }
}

{"type": "error", "code": "unauthorized"}

{"type": "subscribe", "sports": [1], "channels": ["ld", "both"], "snapshot": true}

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
  }
}

{
  "type": "snapshot",
  "part": 0,
  "final": false,
  "events": [
    {
      "id": 1638780974,
      "type": "matchup",
      "startTime": "2026-10-31T15:00:00Z",
      "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}]
        }
      ]
    },
    {
      "id": 1638781120,
      "type": "matchup",
      "startTime": "2026-10-31T15:00:00Z",
      "markets": [
        {
          "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}
          ]
        }
      ]
    }
  ]
}

class Book:
    """Events by rec.id, markets by key, ordered by markets[i].version."""

    def __init__(self) -> None:
        # events[id] = {"rec": event fields, "markets": {key: market}, "seen": {key: tick}, "tick": n}
        self.events: dict[int, dict] = {}
        self.tick = 0                    # bumped on every record applied
        self.sweep_from = None           # tick when the snapshot being served was asked for
        self.sweep_next = None           # the same, for one asked while another is in flight

    def apply_rec(self, rec: dict) -> None:
        """Merge one event record (from odds or from a snapshot)."""
        self.tick += 1
        ev = self.events.setdefault(rec["id"], {"rec": {}, "markets": {}, "seen": {}, "tick": 0})
        ev["tick"] = self.tick
        ev["rec"].update((k, v) for k, v in rec.items() if k != "markets")
        markets, seen = ev["markets"], ev["seen"]
        for m in rec.get("markets") or []:
            key = m.get("key")
            if key is None:
                continue
            seen[key] = self.tick                  # mentioned, even if not newer
            prev = markets.get(key)
            new_v, old_v = m.get("version"), prev.get("version") if prev else None
            if isinstance(new_v, int) and isinstance(old_v, int) and new_v <= old_v:
                continue                           # older than what we hold: skip
            if m.get("status") == "open":
                markets[key] = m
            else:
                markets.pop(key, None)             # anything but "open" closes it
        periods = rec.get("periods") or []
        for p in periods.values() if isinstance(periods, dict) else periods:
            if isinstance(p, dict) and p.get("status") in ("closed", "settled"):
                n = str(p.get("period"))
                for key in [k for k, m in markets.items() if str(m.get("period")) == n]:
                    del markets[key]               # a closed period closes its markets

    def delete(self, event_id) -> None:
        self.events.pop(event_id, None)

    # 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.

    def snapshot_asked(self) -> None:
        """Call when you ask for a snapshot of everything you follow (subscribe included)."""
        if self.sweep_from is None:
            self.sweep_from = self.tick
        elif self.sweep_next is None:
            self.sweep_next = self.tick            # served after the one in flight

    def snapshot_refused(self) -> None:
        """On snapshot_rate_limited. It is about the latest request, and it can arrive
        before the final part of the one still being delivered: forget the latest."""
        if self.sweep_next is not None:
            self.sweep_next = None
        else:
            self.sweep_from = None

    def snapshot_done(self) -> None:
        """On the final part."""
        since, self.sweep_from, self.sweep_next = self.sweep_from, self.sweep_next, None
        if since is None:
            return
        for eid in [i for i, ev in self.events.items() if ev["tick"] <= since]:
            del self.events[eid]                   # not in the snapshot, no update since
        for ev in self.events.values():
            for key in [k for k in ev["markets"] if ev["seen"].get(k, 0) <= since]:
                del ev["markets"][key]             # closed while we were not looking
                ev["seen"].pop(key, None)

    def new_connection(self) -> None:
        """A snapshot in flight dies with its socket. Keep the book, forget the requests."""
        self.sweep_from = self.sweep_next = None

async def session(self, ws) -> None:
    self.book.new_connection()
    await ws.send(json.dumps({"type": "login", "token": KEY}))
    await ws.send(json.dumps(SUBSCRIBE))       # no need to wait for welcome
    self.book.snapshot_asked()                 # the subscribe brings one
    while True:
        msg = json.loads(await asyncio.wait_for(ws.recv(), SILENCE_S))
        kind = msg.get("type")
        if kind == "odds":
            self.on_odds(msg["data"])
        elif kind == "snapshot":
            for rec in msg.get("events") or []:
                self.book.apply_rec(rec)
            if msg.get("final"):
                self.book.snapshot_done()
                log.info("snapshot done, %d events in book", len(self.book.events))
        elif kind == "missed":
            log.warning("missed %s updates: asking for a snapshot", msg.get("count"))
            await self.ask_snapshot(ws)
        elif kind == "feed":
            log.warning("feed %s", msg.get("status"))
            if msg.get("status") == "up":      # updates were lost while it was down
                await self.ask_snapshot(ws)
        elif kind == "error":
            self.on_error(msg)                 # before a close, the close code follows
        elif kind == "welcome":
            log.info("logged in, plan %s", msg["account"]["plan"])
        # subscription, keepalive, pong, status and any new type: nothing to do

def decimal(american: int) -> float:
    return 1 + american / 100 if american > 0 else 1 + 100 / -american

decimal(-238)   # 1.42
decimal(655)    # 7.55

async def run(self) -> None:
    loop = asyncio.get_running_loop()
    delay = BACKOFF_MIN_S
    while True:
        opened = None
        try:
            async with connect(URL, compression=None, max_size=16 * 2**20,
                               open_timeout=10) as ws:
                opened = loop.time()
                await self.session(ws)
        except ConnectionClosed as e:
            code = e.rcvd.code if e.rcvd else 1006
            if code in STOP:
                log.error("closed with %s: not reconnecting", code)
                return
            log.warning("closed with %s", code)
        except (OSError, asyncio.TimeoutError, WebSocketException) as e:
            log.warning("connection lost: %r", e)  # DNS, TCP, TLS, handshake, silence
        if opened is not None and loop.time() - opened > STABLE_S:
            delay = BACKOFF_MIN_S
        wait = max(delay / 2 + random.uniform(0, delay / 2), self.retry_after)
        self.retry_after = 0.0
        log.info("reconnecting in %.1f s", wait)
        await asyncio.sleep(wait)
        delay = min(delay * 2, BACKOFF_MAX_S)  # grow from the last delay, capped

import json
import os
import urllib.request

BASE = "https://feed.oddspush.com/v1"
KEY = os.environ["ODDSPUSH_KEY"]


def get(path: str) -> dict:
    req = urllib.request.Request(BASE + path, headers={"x-token": KEY})
    with urllib.request.urlopen(req, timeout=10) as r:
        return json.loads(r.read())


rows = get("/events?sport_id=1")["events"]               # soccer
for row in [r for r in rows if r["ld"] or r["both"]][:5]:  # open markets on the price channels
    ev = get(f"/events/{row['event_id']}")
    for key, m in ev["merged"].items():                   # ld and both, merged by version
        print(ev["event_id"], key, [(x["designation"], x["price"]) for x in m["prices"]])

Read oddspush-agent-guide.md and follow it. Build a Python client 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.