Quickstart

syntax = "proto3";
package bebop;

message PriceUpdate {
  optional bytes  base            = 1;
  optional bytes  quote           = 2;
  optional uint64 last_update_ts  = 3;
  repeated float  bids            = 4 [packed = true];
  repeated float  asks            = 5 [packed = true];
}

message BebopPricingUpdate {
  repeated PriceUpdate pairs = 1;
}

wss://api.bebop.xyz/pmm/{network}/v3/pricing

import asyncio

import websockets

from bebop_pb2 import BebopPricingUpdate  # type: ignore

NETWORK = "ethereum"
API_KEY = "<your_api_key>"

WSS_URL = (
    f"wss://api.bebop.xyz/pmm/{NETWORK}/v3/pricing"
    f"?format=protobuf"
    f"&gasless=false"
    f"&expiry_type=standard"
)

async def main():
    async with websockets.connect(
        WSS_URL,
        additional_headers={"Authorization": f"Bearer {API_KEY}"},
        ping_interval=20,
        ping_timeout=10,
        max_size=2**21,
    ) as ws:
        print(f"Connected to pricing stream on {NETWORK}")

        async for blob in ws:
            update = BebopPricingUpdate()
            update.ParseFromString(blob)
            print(f"Received {len(update.pairs)} pairs")
asyncio.run(main())

async def fetch_token_list(network: str) -> dict:
    url = f"https://api.bebop.xyz/pmm/{network}/v3/tokenlist"
    resp = httpx.get(url, timeout=10.0)
    resp.raise_for_status()
    return resp.json().get("tokens", {})

tokens_raw = asyncio.run(fetch_token_list(NETWORK))
tokens = {t["symbol"]: t for t in tokens_raw}

# Example: WETH/USDC
base_addr = tokens["WETH"]["address"].lower()
quote_addr = tokens["USDC"]["address"].lower()

def address_to_hex(b: bytes) -> str:
    """Convert raw protobuf bytes to a hex address."""
    return "0x" + b.hex()

def to_levels(flat: list[float]) -> list[tuple[float, float]]:
    """Unpack flat [price, size, price, size, ...] into level tuples."""
    it = iter(flat)
    return list(zip(it, it, strict=True))

async def stream_prices(pair_base: str, pair_quote: str):
    async with websockets.connect(
        WSS_URL,
        additional_headers={"Authorization": f"Bearer {API_KEY}"},
        ping_interval=20,
        ping_timeout=10,
        max_size=2**21,
    ) as ws:
        async for blob in ws:
            update = BebopPricingUpdate()
            update.ParseFromString(blob)

            for pair in update.pairs:
                base_hex = address_to_hex(pair.base)
                quote_hex = address_to_hex(pair.quote)

                if base_hex.lower() != pair_base or quote_hex.lower() != pair_quote:
                    continue

                bids = to_levels(list(pair.bids))
                asks = to_levels(list(pair.asks))

                if not bids or not asks:
                    continue

                best_bid = bids[0][0]
                best_ask = asks[0][0]
                mid_price = (best_bid + best_ask) / 2
                spread_bps = (best_ask - best_bid) / mid_price * 10_000

                print(
                    f"WETH/USDC  mid: {mid_price:.2f}  "
                    f"spread: {spread_bps:.1f} bps  "
                    f"bid levels: {len(bids)}  "
                    f"ask levels: {len(asks)}"
                )

asyncio.run(stream_prices(base_addr, quote_addr))

import asyncio

import httpx
import websockets

from bebop_pb2 import BebopPricingUpdate  # type: ignore

NETWORK = "ethereum"
API_KEY = "<your_api_key>"

WSS_URL = (
    f"wss://api.bebop.xyz/pmm/{NETWORK}/v3/pricing"
    f"?format=protobuf"
    f"&gasless=false"
    f"&expiry_type=standard"
)

PAIR = "WETH/USDC"

def address_to_hex(b: bytes) -> str:
    return "0x" + b.hex()

def to_levels(flat: list[float]) -> list[tuple[float, float]]:
    it = iter(flat)
    return list(zip(it, it, strict=True))

# 1. Resolve token addresses
resp = httpx.get(f"https://api.bebop.xyz/pmm/{NETWORK}/v3/tokenlist", timeout=10.0)
tokens = {t["symbol"]: t for t in resp.json().get("tokens", {})}
base_symbol, quote_symbol = PAIR.split("/")
base_addr = tokens[base_symbol]["address"].lower()
quote_addr = tokens[quote_symbol]["address"].lower()

# 2. Connect to the pricing stream

async def main():
    async with websockets.connect(
        WSS_URL,
        additional_headers={"Authorization": f"Bearer {API_KEY}"},
        ping_interval=20,
        ping_timeout=10,
        max_size=2**21,
    ) as ws:
        print(f"Connected - streaming {PAIR} on {NETWORK}\n")

        async for blob in ws:
            update = BebopPricingUpdate()
            update.ParseFromString(blob)

            for pair in update.pairs:
                if (
                    address_to_hex(pair.base).lower() != base_addr
                    or address_to_hex(pair.quote).lower() != quote_addr
                ):
                    continue

                bids = to_levels(list(pair.bids))
                asks = to_levels(list(pair.asks))

                if not bids or not asks:
                    continue

                best_bid = bids[0][0]
                best_ask = asks[0][0]
                mid = (best_bid + best_ask) / 2
                spread = (best_ask - best_bid) / mid * 10_000

                print(
                    f"{PAIR}  mid: {mid:.2f}  "
                    f"spread: {spread:.1f} bps  "
                    f"best bid: {best_bid:.2f}  "
                    f"best ask: {best_ask:.2f}  "
                    f"levels: {len(bids)}b / {len(asks)}a"
                )
asyncio.run(main())