WebSocket quickstart

wss://api.omnibook.xyz/v1/ws

<timestamp>\nGET\n/v1/ws\n

{
  "id": 1,
  "cmd": "subscribe",
  "params": { "channels": ["orderbook_snapshot", "trades"], "market_ids": [66] }
}

{ "id": 1, "type": "subscribed", "sid": 3, "channel": "orderbook_snapshot" }

#!/usr/bin/env python3
"""Connect, subscribe to the active round's book, print frames."""
import base64, hashlib, hmac, json, time
import websocket  # pip install websocket-client
import requests

BASE = "https://api.omnibook.xyz"
WS_URL = "wss://api.omnibook.xyz/v1/ws"
API_KEY = "<your alphanumeric API key>"
SECRET = bytes.fromhex("<your 64-char hex secret>")


def sign(method: str, target: str, body: bytes = b"") -> dict:
    ts = str(int(time.time() * 1000))
    canonical = f"{ts}\n{method}\n{target}\n".encode() + body
    sig = base64.b64encode(
        hmac.new(SECRET, canonical, hashlib.sha256).digest()
    ).decode()
    return {
        "DX-ACCESS-KEY": API_KEY,
        "DX-ACCESS-TIMESTAMP": ts,
        "DX-ACCESS-SIGNATURE": sig,
    }


# category -> (asset, cadence seconds). Nine series are live.
CATEGORY = {
    1: ("BTC", 60),  2: ("BTC", 300),  3: ("BTC", 900),
    4: ("XAU", 60),  5: ("XAU", 300),  6: ("XAU", 900),
    7: ("WTI", 60),  8: ("WTI", 300),  9: ("WTI", 900),
}


def live_markets() -> dict[int, int]:
    """market_id -> category for every slot currently trading, all series.

    `GET /v1/rounds?limit=1` is NOT the live round: that list interleaves all
    nine series by round_number. Start from the market list instead, then read
    each round to learn which series the slot belongs to — the market object
    does not carry `category`.
    """
    target = "/v1/markets?status=trading"
    r = requests.get(BASE + target, headers=sign("GET", target))
    r.raise_for_status()
    out = {}
    for m in r.json()["markets"]:
        mid = int(m["market_id"])
        rt = f"/v1/rounds/{mid}"
        rr = requests.get(BASE + rt, headers=sign("GET", rt))
        rr.raise_for_status()
        out[mid] = int(rr.json()["category"])
    return out


def main() -> None:
    # Pick the assets you care about. WANT = None subscribes to everything.
    WANT = {"XAU", "WTI"}
    FEEDS = {0: "BTC", 1: "XAU", 2: "WTI"}

    category_of = live_markets()
    market_ids = [
        mid for mid, cat in category_of.items()
        if CATEGORY.get(cat, ("?", 0))[0] in WANT
    ]
    if not market_ids:
        raise SystemExit(f"nothing trading in {WANT} right now (closed session?)")

    headers = sign("GET", "/v1/ws")
    ws = websocket.create_connection(
        WS_URL,
        header=[f"{k}: {v}" for k, v in headers.items()],
    )

    # One subscription can span markets from different assets. The two global
    # channels take no market_ids and cannot be narrowed server-side.
    ws.send(json.dumps({
        "id": 1,
        "cmd": "subscribe",
        "params": {
            "channels": ["orderbook_snapshot", "trades", "rounds", "oracle", "user"],
            "market_ids": market_ids,
        },
    }))

    last_seq: dict[int, int] = {}
    while True:
        frame = json.loads(ws.recv())

        if frame.get("type") == "error":
            print(frame)
            continue

        # Track seq on EVERY frame, before any filtering. A frame you choose to
        # ignore was still delivered — skipping the bookkeeping would look like
        # a gap and trigger an endless re-snapshot loop.
        sid, seq = frame.get("sid"), frame.get("seq")
        if sid is not None and seq is not None:
            prev = last_seq.get(sid)
            if prev is not None and seq != prev + 1:
                # Real gap. Re-snapshot without tearing down the subscription.
                ws.send(json.dumps({
                    "id": 2,
                    "cmd": "update_subscription",
                    "params": {
                        "sid": sid,
                        "action": "get_snapshot",
                        "market_ids": market_ids,
                    },
                }))
            last_seq[sid] = seq

        # Now filter the global channels, or you will mix assets together.
        msg = frame.get("msg") or {}
        if frame.get("type") == "oracle" and FEEDS.get(msg.get("feed")) not in WANT:
            continue
        if frame.get("type") == "rounds":
            if CATEGORY.get(msg.get("category"), ("?", 0))[0] not in WANT:
                continue

        print(frame)


if __name__ == "__main__":
    main()