Quickstart

curl "https://api.sx.bet/markets/active?onlyMainLine=true"

import requests

BASE_URL = "https://api.sx.bet"  # Mainnet — use https://api.toronto.sx.bet for testnet

markets = requests.get(
    f"{BASE_URL}/markets/active",
    params={"onlyMainLine": True}
).json()["data"]["markets"]

first = markets[0]
print("Market hash:", first["marketHash"])
print("Event:", first["teamOneName"], "vs", first["teamTwoName"])
print(f"Outcomes: [1 = {first['outcomeOneName']}, 2 = {first['outcomeTwoName']}]")
print("Start time:", first["gameTime"])

const BASE_URL = "https://api.sx.bet"; // Mainnet — use https://api.toronto.sx.bet for testnet

const data = await fetch(
  `${BASE_URL}/markets/active?onlyMainLine=true`
).then((r) => r.json());
const markets = data.data.markets;

const first = markets[0];
console.log("Market hash:", first.marketHash);
console.log("Event:", first.teamOneName, "vs", first.teamTwoName);
console.log(`Outcomes: [1 = ${first.outcomeOneName}, 2 = ${first.outcomeTwoName}]`);
console.log("Start time:", first.gameTime);

curl "https://api.sx.bet/orderbook-v3/snapshot?marketHash=YOUR_MARKET_HASH&showTakerPerspective=true"

market_hash = "YOUR_MARKET_HASH"  # from step 3

book = requests.get(
    f"{BASE_URL}/orderbook-v3/snapshot",
    params={"marketHash": market_hash, "showTakerPerspective": True}
).json()["data"]

# Best price to bet each outcome. The list is empty if nobody is quoting that side.
for label, levels in (("outcome 1", book["outcomeOne"]), ("outcome 2", book["outcomeTwo"])):
    if not levels:
        print(f"Best price on {label}: no liquidity")
        continue
    best = levels[0]
    print(f"Best price on {label}: {int(best['percentageOdds']) / 10**20:.2%}"
          f" ({best['percentageOdds']}), {int(best['size']) / 1e6:.2f} USDC resting")

const marketHash = "YOUR_MARKET_HASH"; // from step 3

const { data } = await fetch(
  `${BASE_URL}/orderbook-v3/snapshot?${new URLSearchParams({
    marketHash,
    showTakerPerspective: true,
  })}`
).then((r) => r.json());
const book = data;

// Best price to bet each outcome. The list is empty if nobody is quoting that side.
for (const [label, levels] of [["outcome 1", book.outcomeOne], ["outcome 2", book.outcomeTwo]]) {
  const best = levels[0];
  if (!best) {
    console.log(`Best price on ${label}: no liquidity`);
    continue;
  }
  console.log(
    `Best price on ${label}: ${(Number(best.percentageOdds) / 1e18).toFixed(2)}%` +
      ` (${best.percentageOdds}), ${(Number(best.size) / 1e6).toFixed(2)} USDC resting`
  );
}

import os
import secrets
import requests
from eth_account import Account
from eth_account.messages import encode_typed_data
from eth_utils import keccak

BASE_URL = "https://api.sx.bet"  # Mainnet — use https://api.toronto.sx.bet for testnet

account = Account.from_key(os.environ["SX_PRIVATE_KEY"])

market_hash = "YOUR_MARKET_HASH"        # from step 3
percentage_odds = "YOUR_BEST_ODDS"      # from step 4
is_betting_outcome_one = True           # True = bet outcome 1, False = bet outcome 2
stake = "1000000"                       # 1 USDC (6 decimals)

meta = requests.get(f"{BASE_URL}/metadata/obv3").json()["data"]

order = {
    "marketHash": market_hash,
    "baseToken": meta["activeAsset"]["baseToken"],
    "totalBetSize": stake,
    "percentageOdds": percentage_odds,
    "salt": "0x" + secrets.token_hex(32),
    "expiry": 0,                        # 0 = never expires
    "maker": account.address,
    "isMakerBettingOutcomeOne": is_betting_outcome_one,
}

# --- Sign the order ---
DOMAIN = meta["domain"]  # complete EIP-712 domain

ORDER_TYPES = {
    "Order": [
        {"name": "marketHash", "type": "bytes32"},
        {"name": "baseToken", "type": "address"},
        {"name": "totalBetSize", "type": "uint256"},
        {"name": "percentageOdds", "type": "uint256"},
        {"name": "salt", "type": "uint256"},
        {"name": "expiry", "type": "uint256"},
        {"name": "maker", "type": "address"},
        {"name": "isMakerBettingOutcomeOne", "type": "bool"},
    ],
}

# The typed data wants integers where the request body wants strings.
message = {
    **order,
    "totalBetSize": int(order["totalBetSize"]),
    "percentageOdds": int(order["percentageOdds"]),
    "salt": int(order["salt"], 16),
}
signable = encode_typed_data(DOMAIN, ORDER_TYPES, message)
signed = account.sign_message(signable)

# The order id IS the EIP-712 digest, lowercased — compute it and check the server agrees.
order_id = "0x" + keccak(b"\x19" + signable.version + signable.header + signable.body).hex()

# --- Submit ---
response = requests.post(
    f"{BASE_URL}/orders-v3",
    headers={"x-sx-api-key": os.environ["SX_API_KEY"]},
    json={"orders": [{
        **order,
        "timeInForce": "FOK",
        "orderSignature": signed.signature.to_0x_hex(),
    }]},
)
result = response.json()
print("Order result:", result)
print("digest matches:", result["data"]["orders"][0]["orderId"].lower() == order_id)

import "dotenv/config";
import { Wallet, TypedDataEncoder, randomBytes, hexlify } from "ethers";

const BASE_URL = "https://api.sx.bet"; // Mainnet — use https://api.toronto.sx.bet for testnet

const wallet = new Wallet(process.env.SX_PRIVATE_KEY);

const marketHash = "YOUR_MARKET_HASH";     // from step 3
const percentageOdds = "YOUR_BEST_ODDS";   // from step 4
const isBettingOutcomeOne = true;          // true = bet outcome 1, false = bet outcome 2
const stake = "1000000";                   // 1 USDC (6 decimals)

const { data: meta } = await fetch(`${BASE_URL}/metadata/obv3`).then((r) => r.json());

const order = {
  marketHash,
  baseToken: meta.activeAsset.baseToken,
  totalBetSize: stake,
  percentageOdds,
  salt: hexlify(randomBytes(32)),
  expiry: 0,                               // 0 = never expires
  maker: wallet.address,
  isMakerBettingOutcomeOne: isBettingOutcomeOne,
};

// --- Sign the order ---
const domain = meta.domain; // complete EIP-712 domain

const types = {
  Order: [
    { name: "marketHash", type: "bytes32" },
    { name: "baseToken", type: "address" },
    { name: "totalBetSize", type: "uint256" },
    { name: "percentageOdds", type: "uint256" },
    { name: "salt", type: "uint256" },
    { name: "expiry", type: "uint256" },
    { name: "maker", type: "address" },
    { name: "isMakerBettingOutcomeOne", type: "bool" },
  ],
};

const orderSignature = await wallet.signTypedData(domain, types, order);

// The order id IS the EIP-712 digest, lowercased — compute it and check the server agrees.
const orderId = TypedDataEncoder.hash(domain, types, order).toLowerCase();

// --- Submit ---
const response = await fetch(`${BASE_URL}/orders-v3`, {
  method: "POST",
  body: JSON.stringify({
    orders: [{ ...order, timeInForce: "FOK", orderSignature }],
  }),
  headers: {
    "Content-Type": "application/json",
    "x-sx-api-key": process.env.SX_API_KEY,
  },
});
const result = await response.json();
console.log("Order result:", result);
console.log("digest matches:", result.data.orders[0].orderId === orderId);

import asyncio
import os
import aiohttp
from centrifuge import Client, PublicationContext, SubscriptionEventHandler

BASE_URL = "https://api.sx.bet"                       # Mainnet — use https://api.toronto.sx.bet for testnet
WS_URL = "wss://realtime.sx.bet/connection/websocket"  # Testnet: wss://realtime.toronto.sx.bet/connection/websocket

market_hash = "YOUR_MARKET_HASH"                        # from step 3
address = "YOUR_CHECKSUMMED_ADDRESS"                    # your USER address (the maker from step 5), checksummed — NOT the proxy wallet

# Async so the client can refresh the token before its 24h expiry. Passing a
# static string instead would kill the connection once the token lapses.
async def get_token(ctx=None):
    async with aiohttp.ClientSession() as session:
        async with session.get(
            f"{BASE_URL}/user/realtime-token-v3/api-key",
            headers={"x-sx-api-key": os.environ["SX_API_KEY"]},
        ) as resp:
            resp.raise_for_status()
            return (await resp.json())["token"]

async def on_book(ctx: PublicationContext) -> None:
    book = ctx.data
    # Every message is the full resting book — replace your state, don't patch it.
    print("book update:", book["marketHash"], book["outcomeOne"], book["outcomeTwo"])

async def on_order(ctx: PublicationContext) -> None:
    order = ctx.data["order"]
    print("order update:", order["id"], order["status"], order["remainingSize"])

async def main():
    client = Client(WS_URL, get_token=get_token)
    await client.connect()

    book_sub = client.new_subscription(
        f"orderbook_v3:{market_hash}",
        SubscriptionEventHandler(on_publication=on_book),
    )
    await book_sub.subscribe()

    order_sub = client.new_subscription(
        f"account:orders_v3_#{address}",
        SubscriptionEventHandler(on_publication=on_order),
    )
    await order_sub.subscribe()

    await asyncio.Future()  # keep running

asyncio.run(main())

import "dotenv/config";
import { Centrifuge, UnauthorizedError } from "centrifuge";

const BASE_URL = "https://api.sx.bet";                        // Mainnet — use https://api.toronto.sx.bet for testnet
const WS_URL = "wss://realtime.sx.bet/connection/websocket";   // Testnet: wss://realtime.toronto.sx.bet/connection/websocket

const marketHash = "YOUR_MARKET_HASH";                         // from step 3
const address = "YOUR_CHECKSUMMED_ADDRESS";                    // your USER address (the maker from step 5), checksummed — NOT the proxy wallet

// Pass the FUNCTION, not a string, so Centrifugo can refresh the token before it expires.
async function fetchToken() {
  const res = await fetch(`${BASE_URL}/user/realtime-token-v3/api-key`, {
    headers: { "x-sx-api-key": process.env.SX_API_KEY },
  });
  if (res.status === 401 || res.status === 403) throw new UnauthorizedError();
  if (!res.ok) throw new Error(`token endpoint returned ${res.status}`);
  return (await res.json()).token;
}

const client = new Centrifuge(WS_URL, { getToken: fetchToken });
client.connect();

// Public: every message is the full resting book — replace your state, don't patch it.
client
  .newSubscription(`orderbook_v3:${marketHash}`)
  .on("publication", ({ data }) => {
    console.log("book update:", data.marketHash, data.outcomeOne, data.outcomeTwo);
  })
  .subscribe();

// Authenticated: the suffix must match your token's `sub` (your user address, not the proxy wallet).
client
  .newSubscription(`account:orders_v3_#${address}`, { recoverable: true })
  .on("publication", ({ data }) => {
    const order = data.order;
    console.log("order update:", order.id, order.status, order.remainingSize);
  })
  .subscribe();