How to Get Real-Time Bet365 Odds in Python

import os
import time
from itertools import islice
from urllib.parse import quote

import requests

BASE_URL = "https://api.pulsescore.net/api/v3/bet365"

session = requests.Session()
session.headers.update({
    "X-Secret": os.environ["PULSESCORE_API_KEY"],
    "Accept-Encoding": "gzip",
})

PLAN = "basic"  # basic, starter, pro, max or ultra

# Requests allowed per window (seconds), counted per bookmaker
PLAN_RATES = {
    "basic": (1, 1),
    "starter": (1, 60),
    "pro": (1, 1),
    "max": (3, 1),
    "ultra": (6, 1),
}

limit, window = PLAN_RATES[PLAN]
MIN_INTERVAL = window / limit * 1.05  # a little headroom under the limit
_last_request = 0.0


class QuotaExhausted(Exception):
    pass


def _message(resp):
    try:
        return str(resp.json().get("message", ""))
    except ValueError:
        return resp.text


def get(path, **params):
    """GET one endpoint, paced to your plan's per-bookmaker rate."""
    global _last_request
    for _ in range(5):
        wait = _last_request + MIN_INTERVAL - time.monotonic()
        if wait > 0:
            time.sleep(wait)
        _last_request = time.monotonic()
        resp = session.get(BASE_URL + path, params=params, timeout=15)
        if resp.status_code != 429:
            resp.raise_for_status()
            return resp.json()
        message = _message(resp)
        if "Monthly quota" in message:
            raise QuotaExhausted(message)
        # A paused key gets Retry-After; a plain 429 waits one window.
        time.sleep(float(resp.headers.get("Retry-After", window)))
    raise RuntimeError(f"Still rate limited on {path}")

def paginate(path, items_key="events", id_key="eventId", **params):
    """Yield every item of a paginated list once, 30 per request."""
    seen = set()
    page = 1
    while True:
        body = get(path, page=page, limit=30, **params)
        items = body.get(items_key) or []
        for item in items:
            item_id = item.get(id_key)
            if item_id in seen:
                continue  # the board moved while we paged
            seen.add(item_id)
            yield item
        if not items or not body.get("hasNextPage"):
            return
        page += 1

for sport in get("/live-events/sports")["sports"]:
    print(sport["name"], sport["eventCount"])

for event in paginate("/live-events", sport="soccer"):
    score = event.get("score") or {}
    print(f"{event['home']} {score.get('home', '-')}-{score.get('away', '-')} {event['away']}")

leagues = list(paginate("/soccer/leagues", items_key="leagues", id_key="name"))
print(len(leagues), "soccer leagues")

league = "United Kingdom||England Premier League"
events = get(f"/soccer/leagues/{quote(league, safe='')}/events")["events"]
for event in events:
    print(event["startTime"], event["home"], "v", event["away"], event["eventId"])

# The 10 soonest pre-match events: one request, not the whole board
for event in islice(paginate("/soccer/events"), 10):
    print(event["startTime"], event["home"], "v", event["away"])

def find_market(event, canonical, period="FULL_TIME", raw_name=None):
    """The market with this canonicalMarket and period, else by rawName."""
    markets = event.get("markets") or []
    for market in markets:
        if market.get("canonicalMarket") == canonical and market.get("period") == period:
            return market
    for market in markets:
        if raw_name and (market.get("rawName") or "").lower() == raw_name.lower():
            return market
    return None


event = get(f"/soccer/events/{events[0]['eventId']}")["data"]
if event is None:
    print("Unknown event id")
else:
    market = find_market(event, "MATCH_RESULT", raw_name="Full Time Result")
    if market:
        for sel in market["selections"]:
            print(sel.get("canonicalOutcome") or sel["rawName"], sel["odds"])

for market in event["markets"]:
    if market.get("canonicalMarket") != "OVER_UNDER" or market.get("period") != "FULL_TIME":
        continue
    line = next((s["line"] for s in market["selections"] if "line" in s), None)
    prices = {s.get("canonicalOutcome") or s["rawName"]: s["odds"] for s in market["selections"]}
    print(line, prices)

import asyncio
import json
import os

import websockets

WS_URL = "wss://api.pulsescore.net/api/v3/bet365/ws/live"
# No point reconnecting: bad key, plan without WebSocket, unknown sport,
# expired subscription, or a newer connection of yours took the slot.
FATAL_CODES = {4001, 4003, 4004, 4010, 4012}


async def stream(sport):
    url = f"{WS_URL}?key={os.environ['PULSESCORE_API_KEY']}&sport={sport}"
    # A frame carries every live event of the sport: lift the 1 MB default.
    async with websockets.connect(url, max_size=None) as ws:
        async for raw in ws:
            msg = json.loads(raw)
            if msg.get("type") == "connected":
                print(f"Connected: {msg['bookmaker']} {msg['sport']} ({msg['plan']})")
            elif msg.get("type") == "error":
                print("Error:", msg.get("message"))
            else:
                print(f"{msg['count']} live {msg['sport']} events")
                for event in msg["data"][:3]:
                    print("  ", event["home"], "v", event["away"])


async def main(sport="soccer"):
    loop = asyncio.get_running_loop()
    delay = 1
    while True:
        started = loop.time()
        try:
            await stream(sport)
        except websockets.ConnectionClosed as exc:
            code = exc.rcvd.code if exc.rcvd else None
            if code in FATAL_CODES:
                print(f"Closed with {code}: {exc.rcvd.reason}")
                return
        except websockets.InvalidStatus as exc:
            status = exc.response.status_code
            if status not in (429, 502, 503):
                print(f"Handshake refused: HTTP {status}")  # 401 key, 402 plan
                return
            delay = max(delay, int(exc.response.headers.get("Retry-After", 0)))
        except OSError as exc:
            print("Network error:", exc)
        if loop.time() - started > 60:
            delay = 1  # the last connection was healthy
        await asyncio.sleep(delay)
        delay = min(delay * 2, 30)


asyncio.run(main())