SX Bet

https://docs.sx.bet/
Admin
SX Bet is a peer-to-peer sports prediction market exchange where bettors compete against each other...
Tokens:166,538
Snippets:1,406
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Project Dependencies

Source: https://docs.sx.bet/developers/quickstart

Install the necessary libraries for Python or JavaScript development. Ensure you have pip or npm installed.

```bash
pip install requests eth-account python-dotenv
```

```bash
npm install ethers dotenv
```

--------------------------------

### Install Centrifuge SDK

Source: https://docs.sx.bet/llms-full.txt

Commands to remove the legacy Ably package and install the Centrifuge client.

```bash
npm uninstall ably
npm install centrifuge
```

--------------------------------

### Post New Order Request Example

Source: https://docs.sx.bet/api-reference/post-new-order

Example of a signed new order payload for the /orders/new endpoint.

```yaml
POST /orders/new
openapi: 3.0.1
info:
  title: SX Bet API
  version: 1.0.0
  description: >-
    REST API for the SX Bet decentralized sports betting exchange. Retrieve
    sports data, markets, and orderbook information. Post, cancel, and fill
    orders with signed payloads.


    Base URLs:

    - **Mainnet**: `https://api.sx.bet`

    - **Testnet**: `https://api.toronto.sx.bet`
servers:
  - url: https://api.sx.bet
    description: Mainnet (SX Network, chainId 4162)
  - url: https://api.toronto.sx.bet
    description: Testnet (Toronto, chainId 79479957)
security: []
tags:
  - name: Connection
    description: Server metadata and heartbeat management
  - name: Sports Data
    description: Sports, leagues, teams, fixtures, and live scores
  - name: Markets
    description: Active, specific, and popular betting markets
  - name: Trades
    description: Matched trades and portfolio history
  - name: Orders
    description: Orderbook queries, posting, cancelling, and filling orders
paths:
  /orders/new:
    post:
      tags:
        - Orders
      summary: Post a new order
      description: >-
        This endpoint offers new orders on the exchange (market making).
        Offering orders does not cost any fee.
      operationId: postNewOrder
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - orders
              properties:
                orders:
                  type: array
                  items:
                    $ref: '#/components/schemas/SignedNewOrder'
                  description: Array of signed orders to post
            example:
              orders:
                - marketHash: 0x...
                  maker: 0xYourWalletAddress
                  baseToken: '0x6629Ce1Cf35Cc1329ebB4F63202F3f197b3F050B'
                  totalBetSize: '10000000'
                  percentageOdds: '52500000000000000000'
                  expiry: 2209006800
                  apiExpiry: 1735689600
                  executor: '0x52adf738AAD93c31f798a30b2C74D658e1E9a562'
                  salt: 0x...
                  isMakerBettingOutcomeOne: true
                  signature: 0x...
      responses:
        '201':
          description: ''
          content:
            application/json:
              schema:
                type: object
                properties:
                  status:
                    type: string
                    description: '`success` or `failure` if the request succeeded or not'
                  data:
                    type: object
                    properties:
                      orders:
                        type: array
                        items:
                          type: string
                        description: The order hashes corresponding to the new orders
                      statuses:
                        type: object
                        additionalProperties:
                          type: string
                        description: >-
                          Map of order hash to status string for each submitted
                          order
                      inserted:
                        type: number
                        description: The number of new orders successfully inserted
              example:
                status: success
                data:
                  orders:
                    - >-
                      0x7a9d420551c4a635849013dd908f7894766e97aee25fe656d0c5ac857e166fac
                  statuses:
                    '0x7a9d420551c4a635849013dd908f7894766e97aee25fe656d0c5ac857e166fac': OK
                  inserted: 1
        '400':
          description: >-
            Error Codes:


            `TOO_MANY_DIFFERENT_MARKETS` — More than 3 different markets queried


            `ORDERS_MUST_HAVE_IDENTICAL_MARKET` — All orders must be for the
            same network, either `SXN` or `SXR`


            `BAD_BASE_TOKEN` — All orders must be for the same base token,
            either `USDC` or `WSX`


            `ACCOUNT_SUSPENDED` — Your account has been suspended


            `INSUFFICIENT_KYC` — user has not registered on sx.bet
          content:
            application/json:
              schema:
                type: object
                properties:
                  status:
                    type: string
                  errorCode:
                    type: string
x-codeSamples:
  - lang: javascript
    label: Sign & Post Order
    source: >-
      import { Wallet, solidityPackedKeccak256, getBytes, randomBytes,
      hexlify } from "ethers";


      const order = {
        marketHash:
          "0x0eeace4a9bbf6235bc59695258a419ed3a05a2c8e3b6a58fb71a0d9e6b031c2b",
        maker: "0x6F75bA6c90E3da79b7ACAfc0fb9cf3968aa4ee39",
        totalBetSize: "10000000",

```

--------------------------------

### Active Markets Response Example

Source: https://docs.sx.bet/api-reference/get-markets-active

Example JSON response showing a list of active markets and a pagination key.

```json
status: success
data:
  markets:
    - status: ACTIVE
      marketHash: >-
        0x8120ae9408cd7556246473be7ceada8cba47d42418cce31ffad0b67b196e3218
      outcomeOneName: Golden State Warriors
      outcomeTwoName: Minnesota Timberwolves
      outcomeVoidName: NO_CONTEST
      teamOneName: Golden State Warriors
      teamTwoName: Minnesota Timberwolves
      type: 226
      gameTime: 1773453600
      sportXeventId: L18272456
      liveEnabled: true
      sportLabel: Basketball
      sportId: 1
      leagueId: 1
      leagueLabel: NBA
      group1: NBA
      chainVersion: SXR
      participantOneId: 15002
      participantTwoId: 14999
      __type: Market
    - status: ACTIVE
      marketHash: >-
        0x531e9e6d6469f6323d464340e91840b3666e4e43cf04b8c2a52c2ac0d67839fb
      outcomeOneName: Golden State Warriors +6.5
      outcomeTwoName: Minnesota Timberwolves -6.5
      outcomeVoidName: NO_GAME_OR_EVEN
      teamOneName: Golden State Warriors
      teamTwoName: Minnesota Timberwolves
      type: 342
      gameTime: 1773453600
      line: 6.5
      sportXeventId: L18272456
      liveEnabled: true
      sportLabel: Basketball
      sportId: 1
      leagueId: 1
      leagueLabel: NBA
      group1: NBA
      chainVersion: SXR
      participantOneId: 15002
      participantTwoId: 14999
      mainLine: true
      __type: Market
  nextKey: 60c7b8f54da0ad001aa3261c
```

--------------------------------

### Install Centrifuge SDKs

Source: https://docs.sx.bet/llms-full.txt

Use these commands to install the necessary Centrifuge client libraries for JavaScript or Python environments.

```bash
npm install centrifuge
```

```bash
pip install centrifuge-python requests
```

--------------------------------

### Search Fixtures Response Example

Source: https://docs.sx.bet/api-reference/search

Example JSON response structure returned by the /search endpoint upon a successful query.

```json
{
  "status": "success",
  "data": [
    {
      "gameTime": "2026-04-28T02:10:00.000Z",
      "teamOneName": "Los Angeles Dodgers",
      "teamTwoName": "Miami Marlins",
      "providerEventId": "17495682",
      "provider": "LSPORT",
      "type": [
        28,
        226,
        236,
        342,
        1618
      ],
      "eventId": "L17495682",
      "chainVersion": "SXR",
      "league": {
        "leagueId": 171,
        "sportId": 3,
        "label": "MLB"
      }
    }
  ]
}
```

--------------------------------

### Install Dependencies

Source: https://docs.sx.bet/llms-full.txt

Required packages for Python and JavaScript environments.

```bash
pip install requests eth-account python-dotenv
```

```bash
npm install ethers dotenv
```

--------------------------------

### Uninstall Ably and Install Centrifuge SDK

Source: https://docs.sx.bet/api-reference/centrifugo-migration

Use npm to remove the Ably SDK and install the Centrifuge SDK.

```bash
npm uninstall ably
npm install centrifuge
```

--------------------------------

### Install Centrifuge Client (npm)

Source: https://docs.sx.bet/api-reference/centrifugo-initialization

Install the Centrifuge JavaScript client using npm. This is required for browser and Node.js applications.

```bash
npm install centrifuge
```

--------------------------------

### Fill Order Request Example

Source: https://docs.sx.bet/api-reference/post-fill-order

Example JSON payload for the fillOrder operation. Ensure the fillSalt matches the value used during the signing process.

```json
{
  "market": "N/A",
  "baseToken": "0x6629Ce1Cf35Cc1329ebB4F63202F3f197b3F050B",
  "isTakerBettingOutcomeOne": true,
  "stakeWei": "50000000",
  "desiredOdds": "83000000000000000000",
  "oddsSlippage": 5,
  "fillSalt": "0x...",
  "taker": "0xYourWalletAddress",
  "takerSig": "0x..."
}
```

--------------------------------

### Retrieve available sports via OpenAPI

Source: https://docs.sx.bet/api-reference/get-sports

Defines the GET /sports endpoint for the SX Bet API, including the response schema and example data.

```yaml
openapi: 3.0.1
info:
  title: SX Bet API
  version: 1.0.0
  description: >-
    REST API for the SX Bet decentralized sports betting exchange. Retrieve
    sports data, markets, and orderbook information. Post, cancel, and fill
    orders with signed payloads.


    Base URLs:

    - **Mainnet**: `https://api.sx.bet`

    - **Testnet**: `https://api.toronto.sx.bet`
servers:
  - url: https://api.sx.bet
    description: Mainnet (SX Network, chainId 4162)
  - url: https://api.toronto.sx.bet
    description: Testnet (Toronto, chainId 79479957)
security: []
tags:
  - name: Connection
    description: Server metadata and heartbeat management
  - name: Sports Data
    description: Sports, leagues, teams, fixtures, and live scores
  - name: Markets
    description: Active, specific, and popular betting markets
  - name: Trades
    description: Matched trades and portfolio history
  - name: Orders
    description: Orderbook queries, posting, cancelling, and filling orders
paths:
  /sports:
    get:
      tags:
        - Sports Data
      summary: Get sports
      description: This endpoint retrieves all sports available on the exchange
      operationId: getSports
      responses:
        '200':
          description: ''
          content:
            application/json:
              schema:
                type: object
                properties:
                  status:
                    type: string
                    description: '`success` or `failure` if the request succeeded or not'
                  data:
                    type: array
                    items:
                      $ref: '#/components/schemas/Sport'
              example:
                status: success
                data:
                  - sportId: 1
                    label: Soccer
                  - sportId: 2
                    label: Basketball
                  - sportId: 3
                    label: American Football
components:
  schemas:
    Sport:
      type: object
      properties:
        sportId:
          type: integer
          description: Unique identifier for the sport
          example: 1
        label:
          type: string
          description: Human-readable sport name
          example: Soccer
```

--------------------------------

### Switch environments via CLI

Source: https://docs.sx.bet/llms-full.txt

Demonstrates how to toggle between testnet and mainnet by setting the SX_ENV environment variable at runtime.

```bash
# Testnet (default)
SX_ENV=testnet node your-bot.js

# Mainnet
SX_ENV=mainnet node your-bot.js
```

--------------------------------

### Subscribe to a channel

Source: https://docs.sx.bet/llms-full.txt

Demonstrates how to initialize a subscription and handle publication events in JavaScript and Python.

```javascript
const sub = client.newSubscription("channel:name", { positioned: true, recoverable: true });

sub.on("publication", (ctx) => {
  const data = ctx.data;
  // handle incoming message
});

sub.subscribe();
```

```python
import asyncio
from centrifuge import Client, PublicationContext, SubscriptionEventHandler

async def on_publication(ctx: PublicationContext) -> None:
    print(ctx.data)

async def main():
    client = Client(
        "wss://realtime.sx.bet/connection/websocket",
        token="YOUR_TOKEN",  # from /user/realtime-token/api-key
    )
    await client.connect()
    handler = SubscriptionEventHandler(on_publication=on_publication)
    sub = client.new_subscription("channel:name", handler)
    await sub.subscribe()
    await asyncio.Future()  # keep running

asyncio.run(main())
```

--------------------------------

### GET /trades/consolidated

Source: https://docs.sx.bet/llms-full.txt

Get consolidated trade history with pagination on the SX Bet exchange.

```APIDOC
## GET /trades/consolidated

### Description
Get consolidated trade history with pagination on the SX Bet exchange.

### Method
GET

### Endpoint
/trades/consolidated

### Parameters
#### Query Parameters
- **bettor** (string) - Optional - Filter by bettor address
- **marketHash** (string) - Optional - Filter by market hash
```

--------------------------------

### Subscribe to Market Updates (Python)

Source: https://docs.sx.bet/api-reference/centrifugo-market-updates

This Python example demonstrates how to subscribe to real-time market updates using the centrifuge library. Replace 'YOUR_TOKEN' with your actual realtime token.

```python
import asyncio
from centrifuge import Client, PublicationContext, SubscriptionEventHandler

async def on_publication(ctx: PublicationContext) -> None:
    print(ctx.data)

async def main():
    client = Client(
        "wss://realtime.sx.bet/connection/websocket",
        token="YOUR_TOKEN",  # from /user/realtime-token/api-key
    )
    await client.connect()
    handler = SubscriptionEventHandler(on_publication=on_publication)
    sub = client.new_subscription("markets:global", handler)
    await sub.subscribe()
    await asyncio.Future()  # keep running

asyncio.run(main())
```

--------------------------------

### GET /markets/popular

Source: https://docs.sx.bet/llms-full.txt

Get the most popular betting markets by volume on the SX Bet exchange.

```APIDOC
## GET /markets/popular

### Description
Get the most popular betting markets by volume on the SX Bet exchange.

### Method
GET

### Endpoint
/markets/popular
```

--------------------------------

### Subscribe to a Channel in Python

Source: https://docs.sx.bet/api-reference/centrifugo-initialization

Establish a connection to the Centrifuge server and create a subscription to a specified channel. This example demonstrates setting up a publication handler and keeping the client running to receive messages. Replace 'wss://realtime.sx.bet/connection/websocket' and 'YOUR_TOKEN' with your actual server endpoint and authentication token.

```python
import asyncio
from centrifuge import Client, PublicationContext, SubscriptionEventHandler

async def on_publication(ctx: PublicationContext) -> None:
    print(ctx.data)

async def main():
    client = Client(
        "wss://realtime.sx.bet/connection/websocket",
        token="YOUR_TOKEN",  # from /user/realtime-token/api-key
    )
    await client.connect()
    handler = SubscriptionEventHandler(on_publication=on_publication)
    sub = client.new_subscription("channel:name", handler)
    await sub.subscribe()
    await asyncio.Future()  # keep running

asyncio.run(main())
```

--------------------------------

### Sign & Cancel Orders in Python

Source: https://docs.sx.bet/api-reference/post-cancel-orders

Initializes the environment for signing and cancelling orders using the eth_account library.

```python
import os, secrets, requests

from eth_account import Account
```

--------------------------------

### Message Payload Example

Source: https://docs.sx.bet/api-reference/centrifugo-line-changes

Example of the JSON structure returned in the message payload for line changes.

```json
{
  "marketHash": "0x38cceead7bda65c18574a34994ebd8af154725d08aa735dcbf26247a7dcc67bd",
  "marketType": 3,
  "sportXEventId": "L7178624"
}
```

--------------------------------

### Example Taker Odds Calculation

Source: https://docs.sx.bet/llms-full.txt

Calculation example for determining the desired odds when betting on outcome one.

```text
10^20 - 52500000000000000000 = 47500000000000000000 (47.5%)
```

--------------------------------

### Example fixture response

Source: https://docs.sx.bet/llms-full.txt

A sample JSON object representing an active fixture event.

```json
{
  "participantOneName": "William Jewell",
  "participantTwoName": "Indianapolis",
  "startDate": "2020-11-28T03:45:00.000Z",
  "status": 1,
  "leagueId": 2,
  "leagueLabel": "NCAA",
  "sportId": 1,
  "eventId": "L6217784"
}
```

--------------------------------

### Best Odds Response Example

Source: https://docs.sx.bet/api-reference/get-best-odds

Example JSON response structure for a successful best odds query.

```json
{
  "status": "success",
  "data": {
    "bestOdds": [
      {
        "marketHash": "0xbe621aead370a0c8c48fcfcff6fa60c49126683f4ba30945fbb94fcf8fb3fe9e",
        "baseToken": "0x6629Ce1Cf35Cc1329ebB4F63202F3f197b3F050B",
        "outcomeOne": {
          "percentageOdds": "65750000000000000000",
          "updatedAt": 1773008449368
        },
        "outcomeTwo": {
          "percentageOdds": "33000000000000000000",
          "updatedAt": 1773007355305
        }
      }
    ]
  }
}
```

--------------------------------

### CE Refund Event Payload Example

Source: https://docs.sx.bet/api-reference/centrifugo-ce-refund-events

Example JSON structure of the message payload received from the subscription.

```json
[
  {
    "marketHash": "0x3e012cc2842849b96768547d4c92720d7ee8946e7706323f5114b6451708cf5e",
    "baseToken": "0x1BC6326EA6aF2aB8E4b68c83418044B1923b2956",
    "totalRefunded": 2.346033,
    "events": [
      {
        "maker": false,
        "amount": "2.346033",
        "bettor": "0xaD6A65315Cb20dD0b9D0Af56213516727a20C66F",
        "baseToken": "0x1BC6326EA6aF2aB8E4b68c83418044B1923b2956",
        "createdAt": "2025-10-21T14:29:26.805266+00:00",
        "marketHash": "0x3e012cc2842849b96768547d4c92720d7ee8946e7706323f5114b6451708cf5e",
        "fillOrderHash": "0x7efa8ee211c5cbccebda722318252ee09cfadaa9c910bf4c433086d853784b02"
      }
    ]
  }
]
```

--------------------------------

### Configure AI Coding Assistants for SX Bet

Source: https://docs.sx.bet/developers/introduction

Connect AI coding assistants to SX Bet documentation via MCP to enable live context awareness.

```bash
claude mcp add --transport http sx-bet https://docs.sx.bet/mcp
```

```json
// .cursor/mcp.json
{
  "mcpServers": {
    "sx-bet": { "url": "https://docs.sx.bet/mcp" }
  }
}
```

```json
// .vscode/mcp.json
{
  "servers": {
    "sx-bet": { "type": "http", "url": "https://docs.sx.bet/mcp" }
  }
}
```

```json
// Windsurf Settings → MCP Configuration
{
  "mcpServers": {
    "sx-bet": { "url": "https://docs.sx.bet/mcp" }
  }
}
```

--------------------------------

### Initialize Ably Connection with Authentication Callback

Source: https://docs.sx.bet/api-reference/ws-initialization

This snippet demonstrates how to initialize the Ably Realtime client with a custom authentication callback. The callback fetches a token request from the SX Bet API. Ensure the SX_BET_API_KEY environment variable is set.

```javascript
import * as ably from "ably";

async function createTokenRequest() {
  const response = await fetch("https://api.sx.bet/user/token", {
    headers: {
      "X-Api-Key": process.env.SX_BET_API_KEY,
    },
  });
  return response.json();
}

async function initialize() {
  const realtime = new ably.Realtime.Promise({
    authCallback: async (tokenParams, callback) => {
      try {
        const tokenRequest = await createTokenRequest();
        // Make a network request to GET /user/token passing in
        // `X-Api-Key: [YOUR_API_KEY]` as a header
        callback(null, tokenRequest);
      } catch (error) {
        callback(error, null);
      }
    },
  });
  await ablyClient.connection.once("connected");
}
```

--------------------------------

### Live Score JSON Payload Example

Source: https://docs.sx.bet/api-reference/centrifugo-live-score-updates

Example structure of the JSON data received from the live scores channel.

```json
{
  "teamOneScore": 2,
  "teamTwoScore": 1,
  "sportXEventId": "L7178624",
  "currentPeriod": "4th Set",
  "periodTime": "-1",
  "sportId": 6,
  "leagueId": 1263,
  "periods": [
    {
      "label": "1st Set",
      "isFinished": true,
      "teamOneScore": "4",
      "teamTwoScore": "6"
    },
    {
      "label": "4th Set",
      "isFinished": false,
      "teamOneScore": "1",
      "teamTwoScore": "2"
    }
  ],
  "extra": "..."
}
```

--------------------------------

### Subscribe to Best Odds Updates (Python)

Source: https://docs.sx.bet/api-reference/centrifugo-best-odds

This Python example demonstrates how to connect to the real-time service, subscribe to the 'best_odds:global' channel, and process incoming data using the centrifuge library. Replace 'YOUR_TOKEN' with your actual API key.

```python
import asyncio
from centrifuge import Client, PublicationContext, SubscriptionEventHandler

async def on_publication(ctx: PublicationContext) -> None:
    print(ctx.data)

async def main():
    client = Client(
        "wss://realtime.sx.bet/connection/websocket",
        token="YOUR_TOKEN",  # from /user/realtime-token/api-key
    )
    await client.connect()
    handler = SubscriptionEventHandler(on_publication=on_publication)
    sub = client.new_subscription("best_odds:global", handler)
    await sub.subscribe()
    await asyncio.Future()  # keep running

asyncio.run(main())
```

--------------------------------

### Configure Private Key Environment Variable

Source: https://docs.sx.bet/developers/accounts

Store your private key securely in a .env file to avoid hardcoding it in your application.

```bash
SX_PRIVATE_KEY="0xyour_private_key_here"
```

--------------------------------

### Install Centrifuge Client (pip)

Source: https://docs.sx.bet/api-reference/centrifugo-initialization

Install the Centrifuge Python client and requests library using pip. This is required for Python applications.

```bash
pip install centrifuge-python requests
```

--------------------------------

### Defining main and alternate lines

Source: https://docs.sx.bet/llms-full.txt

Example showing how to distinguish between main and alternate lines using the mainLine boolean field.

```json
{ "type": 2, "line": 1.5, "mainLine": false }   // alternate line
{ "type": 2, "line": 2.5, "mainLine": true }    // main line
{ "type": 2, "line": 3.5, "mainLine": false }    // alternate line
```

--------------------------------

### GET /metadata OpenAPI Specification

Source: https://docs.sx.bet/api-reference/get-metadata

This OpenAPI snippet defines the GET /metadata endpoint, which retrieves exchange metadata and parameters for interacting with the SX Bet API. It includes details on server URLs, fees, and contract addresses.

```yaml
openapi: 3.0.1
info:
  title: SX Bet API
  version: 1.0.0
  description: >-
    REST API for the SX Bet decentralized sports betting exchange. Retrieve
    sports data, markets, and orderbook information. Post, cancel, and fill
    orders with signed payloads.


    Base URLs:

    - **Mainnet**: `https://api.sx.bet`

    - **Testnet**: `https://api.toronto.sx.bet`
servers:
  - url: https://api.sx.bet
    description: Mainnet (SX Network, chainId 4162)
  - url: https://api.toronto.sx.bet
    description: Testnet (Toronto, chainId 79479957)
security: []
tags:
  - name: Connection
    description: Server metadata and heartbeat management
  - name: Sports Data
    description: Sports, leagues, teams, fixtures, and live scores
  - name: Markets
    description: Active, specific, and popular betting markets
  - name: Trades
    description: Matched trades and portfolio history
  - name: Orders
    description: Orderbook queries, posting, cancelling, and filling orders
paths:
  /metadata:
    get:
      tags:
        - Connection
      summary: Get metadata
      description: >-
        This endpoint retrieves metadata on the exchange itself and useful
        parameters to interact with the exchange.
      operationId: getMetadata
      responses:
        '200':
          description: ''
          content:
            application/json:
              schema:
                type: object
                properties:
                  status:
                    type: string
                    example: success
                  data:
                    $ref: '#/components/schemas/Metadata'
              example:
                status: success
                data:
                  executorAddress: '0x52adf738AAD93c31f798a30b2C74D658e1E9a562'
                  oracleFees:
                    '0x6629Ce1Cf35Cc1329ebB4F63202F3f197b3F050B':
                      '0': '0'
                      '1': '0'
                      '2': '5000000000000000000'
                      '3': '5000000000000000000'
                    '0x3E96B0a25d51e3Cc89C557f152797c33B839968f':
                      '0': '0'
                      '1': '0'
                      '2': '5000000000000000000'
                      '3': '5000000000000000000'
                  sportXAffiliate:
                    address: '0x0000000000000000000000000000000000000000'
                    amount: '0'
                  makerOrderMinimums:
                    '0x6629Ce1Cf35Cc1329ebB4F63202F3f197b3F050B': '10000000'
                    '0x3E96B0a25d51e3Cc89C557f152797c33B839968f': '30000000000000000000'
                  takerMinimums:
                    '0x6629Ce1Cf35Cc1329ebB4F63202F3f197b3F050B': '1000000'
                    '0x3E96B0a25d51e3Cc89C557f152797c33B839968f': '30000000000000000000'
                  addresses:
                    '4162':
                      USDC: '0x6629Ce1Cf35Cc1329ebB4F63202F3f197b3F050B'
                      WSX: '0x3E96B0a25d51e3Cc89C557f152797c33B839968f'
                  EIP712FillHasher: '0x845a2Da2D70fEDe8474b1C8518200798c60aC364'
                  TokenTransferProxy: '0x38aef22152BC8965bf0af7Cf53586e4b0C4E9936'
                  oddsLadderStepSize: 125
                  bridgeFee: 1
                  depositBridgeFee: 0
                  withdrawalBridgeFee: 0
                  depositBridgeFeeEthereum: 1
                  minimumDepositAmountEthereum: 10
                  depositBridgeFeeArbitrum: 0.1
                  minimumDepositAmountArbitrum: 5
                  withdrawBridgeFeeArbitrum: 0
                  popularSports:
                    - 6
                    - 1
                    - 5
                  leagueOrderingBySport:
                    '1':
                      - 1
                      - 2
                    '8':
                      - 243
                      - 246
                  cashoutFee: '0'
                  crosschainFees:
                    '137': 0.03
                    '42161': 0.03
                    '80094': 0.03
                  chainVersion: SXR
                  domainVersion: '6.0'
        '500':
          description: Internal server error
components:
  schemas:
    Metadata:
      type: object
      properties:
        executorAddress:
          type: string
          description: >-
            The executor address for the sx.bet exchange. Use this address for
            setting the `executor` when posting new orders as a market maker.
        oracleFees:
          type: object
          additionalProperties:
            type: object
            additionalProperties:
              type: string
          description: >-
            A mapping from token address to an object of fee tiers (0–3) to fee
            amounts. Tiers 0 and 1 are 0; tiers 2 and 3 indicate the fees paid
            on profit. To convert to a readable number, divide by 10^20
        sportXAffiliate:
          type: object
          properties:

```

--------------------------------

### Initialize Ably Client and Subscribe to Orders

Source: https://docs.sx.bet/api-reference/ws-best-practices

Initializes the Ably client with authentication and subscribes to order updates for a specific market and token. Uses the 'rewind' parameter to ensure data continuity. Requires the 'ably' package.

```javascript
const Ably = require("ably");

async function getOrders(marketHash, token) {
  const response = await fetch(
    `https://api.sx.bet/orders?marketHashes=${marketHash}&baseToken=${token}`,
    {
      headers: {
        "Content-Type": "application/json",
        "X-Api-Key": this.apiKey,
      },
    }
  );
  console.log(await response.json());
}

async function orderStream(realtime, marketHash, token) {
  const channel = realtime.channels.get(`order_book:${token}:${marketHash}`, {
    params: { rewind: "10s" },
  });
  channel.subscribe((message) => {
    console.log(message.data);
  });
}

async function createTokenRequest() {
  console.log("createTokenRequest");
  const response = await fetch("https://api.sx.bet/user/token", {
    headers: {
      "X-Api-Key": this.apiKey,
      "Content-Type": "application/json",
    },
  });
  return response.json();
}

async function initialize() {
  const ablyClient = new Ably.Realtime.Promise({
    authUrl: "https://ably.com/ably-auth/token/docs",
  });
  const realtime = new Ably.Realtime.Promise({
    authCallback: async (tokenParams, callback) => {
      try {
        const tokenRequest = await createTokenRequest();
        callback(null, tokenRequest);
      } catch (error) {
        callback(error, null);
      }
    },
  });
  await ablyClient.connection.once("connected");
  return realtime;
}

async function main() {
  const realtime = await initialize();
  await getOrders(this.marketHash, this.token);
  await orderStream(realtime, this.marketHash, this.token);
}

main();

```

--------------------------------

### Get Active Leagues OpenAPI Specification

Source: https://docs.sx.bet/api-reference/get-leagues-active

This OpenAPI specification defines the GET /leagues/active endpoint. It retrieves leagues with active markets and is updated every 10 minutes. The response includes league details and the number of events by type.

```yaml
GET /leagues/active
openapi: 3.0.1
info:
  title: SX Bet API
  version: 1.0.0
  description: >-
    REST API for the SX Bet decentralized sports betting exchange. Retrieve
    sports data, markets, and orderbook information. Post, cancel, and fill
    orders with signed payloads.


  Base URLs:

  - **Mainnet**: `https://api.sx.bet`

  - **Testnet**: `https://api.toronto.sx.bet`
servers:
  - url: https://api.sx.bet
    description: Mainnet (SX Network, chainId 4162)
  - url: https://api.toronto.sx.bet
    description: Testnet (Toronto, chainId 79479957)
security: []
tags:
  - name: Connection
    description: Server metadata and heartbeat management
  - name: Sports Data
    description: Sports, leagues, teams, fixtures, and live scores
  - name: Markets
    description: Active, specific, and popular betting markets
  - name: Trades
    description: Matched trades and portfolio history
  - name: Orders
    description: Orderbook queries, posting, cancelling, and filling orders
paths:
  /leagues/active:
    get:
      tags:
        - Sports Data
      summary: Get active leagues
      description: >-
        This endpoint returns all the currently active leagues with markets in
        them. Note that this endpoint is only updated every 10m. The response
        format is the same as the get leagues endpoint, with an additional field
        `eventsByType` which maps the number of unique events within a
        particular bet group (for example, `game-lines` or `outright-winner`).
      operationId: getActiveLeagues
      parameters:
        - name: sportId
          in: query
          required: false
          schema:
            type: integer
          description: Only return active leagues under this sport
      responses:
        '200':
          description: ''
          content:
            application/json:
              schema:
                type: object
                properties:
                  status:
                    type: string
                    description: '`success` or `failure` if the request succeeded or not'
                  data:
                    type: array
                    items:
                      type: object
                      properties:
                        leagueId:
                          type: integer
                          description: The ID for this league
                          example: 1236
                        label:
                          type: string
                          description: The name of this league
                          example: Portugal Primeira Liga
                        sportId:
                          type: integer
                          description: The ID of the sport this league corresponds to
                          example: 5
                        eventsByType:
                          type: object
                          description: >-
                            Maps bet group types to the number of unique events
                            within that type
                          additionalProperties:
                            type: integer
              example:
                status: success
                data:
                  - leagueId: 1236
                    label: Portugal Primeira Liga
                    sportId: 5
                    eventsByType:
                      game-lines: 6
                      1X2: 5

```

--------------------------------

### Configure Claude Desktop MCP

Source: https://docs.sx.bet/developers/build-on-sx-with-ai

Add the SX Bet MCP server to the Claude Desktop configuration file.

```json
{
  "mcpServers": {
    "sx-bet": {
      "url": "https://docs.sx.bet/mcp"
    }
  }
}
```

--------------------------------

### Get Fixture Status OpenAPI Spec

Source: https://docs.sx.bet/api-reference/get-fixture-status

This OpenAPI specification defines the GET /fixture/status endpoint. It allows fetching the status of specific fixtures by providing an array of event IDs. The response includes a status code and detailed fixture status.

```yaml
GET /fixture/status
openapi: 3.0.1
info:
  title: SX Bet API
  version: 1.0.0
  description: >-
    REST API for the SX Bet decentralized sports betting exchange. Retrieve
    sports data, markets, and orderbook information. Post, cancel, and fill
    orders with signed payloads.


  Base URLs:

  - **Mainnet**: `https://api.sx.bet`

  - **Testnet**: `https://api.toronto.sx.bet`
servers:
  - url: https://api.sx.bet
    description: Mainnet (SX Network, chainId 4162)
  - url: https://api.toronto.sx.bet
    description: Testnet (Toronto, chainId 79479957)
security: []
tags:
  - name: Connection
    description: Server metadata and heartbeat management
  - name: Sports Data
    description: Sports, leagues, teams, fixtures, and live scores
  - name: Markets
    description: Active, specific, and popular betting markets
  - name: Trades
    description: Matched trades and portfolio history
  - name: Orders
    description: Orderbook queries, posting, cancelling, and filling orders
paths:
  /fixture/status:
    get:
      tags:
        - Sports Data
      summary: Get fixture status
      description: This endpoint returns the status of the passed event IDs.
      operationId: getFixtureStatus
      parameters:
        - name: sportXEventIds
          in: query
          required: true
          schema:
            type: array
            items:
              type: string
          description: An array of event IDs (comma separated)
      responses:
        '200':
          description: ''
          content:
            application/json:
              schema:
                type: object
                properties:
                  status:
                    type: string
                    description: '`success` or `failure` if the request succeeded or not'
                  data:
                    type: object
                    description: >-
                      Mapping from event ID to an object containing the fixture
                      status code.
                    additionalProperties:
                      type: object
                      properties:
                        status:
                          type: integer
                          description: >-
                            The status code for this fixture. See the [status
                            table](/api-reference/fixture-statuses) for more
                            details.
              example:
                status: success
                data:
                  L18016511:
                    status: 1
        '400':
          description: >-
            Bad request — `sportXEventIds` is empty or contains more than 30
            event IDs

```

--------------------------------

### Subscribe to Line Changes

Source: https://docs.sx.bet/api-reference/centrifugo-line-changes

Examples for subscribing to the main_line:global channel to receive real-time updates on market line changes.

```javascript
// To subscribe
const sub = client.newSubscription("main_line:global", { positioned: true, recoverable: true });

sub.on("publication", (ctx) => {
  const data = ctx.data;
  // message handler logic
});

sub.subscribe();
```

```python
import asyncio
from centrifuge import Client, PublicationContext, SubscriptionEventHandler

async def on_publication(ctx: PublicationContext) -> None:
    print(ctx.data)

async def main():
    client = Client(
        "wss://realtime.sx.bet/connection/websocket",
        token="YOUR_TOKEN",  # from /user/realtime-token/api-key
    )
    await client.connect()
    handler = SubscriptionEventHandler(on_publication=on_publication)
    sub = client.new_subscription("main_line:global", handler)
    await sub.subscribe()
    await asyncio.Future()  # keep running

asyncio.run(main())
```
Tokens:
Raw