Skip to content

Getting started

Before you start, create OAuth 2.0 credentials (a client_id / client_secret) for your white label in the Betting Backoffice. You exchange them for a short-lived access token that authenticates your API requests.

Note

Read more info within the Authorization section.

Common integration with the DATA.BET Sportsbook can be described using the next diagram:

Typical sportsbook integration scheme

Connecting to API

Every request to our API must carry a Bearer access token obtained from your OAuth 2.0 credentials.

For detailed information on how to obtain a token and authenticate requests, including curl examples, refer to the Authorization documentation.

IP whitelist

On top of authentication, the Betting API is restricted to a per-whitelabel allowlist of client IP addresses. A request that authenticates correctly but originates from an IP that isn't on your list is rejected with HTTP 403 Forbidden. Before you start making requests, make sure your outbound IPs are whitelisted.

You manage this list yourself through the Betting Backoffice — see the IP Whitelist guide.

MCP server

The Betting API is available as an MCP ⤴ (Model Context Protocol) server. Connect an MCP-capable AI tool to it and explore the API conversationally instead of assembling requests by hand. It can search the published API documentation directly — list the available specs, look up an operation's request schema, or list the callbacks you need to implement — and it can call the live API on your behalf, for example to look up a dictionary value, create a freebet, or check a bet report.

Integration environment only

This server calls the Betting API on betting.int.databet.cloud, the integration environment (see Authorization). It is not intended for production traffic. Use it to explore the API and validate your integration, then move to the production Betting API for real bets.

What it exposes

The server gives an AI assistant two kinds of tools.

Documentation tools — query the published contract directly, no live API call involved:

  • get_contract — with no arguments, every bundled spec and who implements it; with a spec name, its operations; with a spec and an operation, that operation's full request schema, resolved.
  • list_callback_endpoints — every callback endpoint you must implement, with the request it sends and the response it expects.
  • build_callback_fixture — a spec-conformant example payload for a callback endpoint, built from the spec's own documented examples.

API tools — one tool per Betting API operation, bundled from every spec published in this docs section:

Banners and the bet, cash out, insurance and heartbeat callbacks are not called this way — you implement them, and the platform calls you. Discover their contract through list_callback_endpoints and build_callback_fixture above.

If an operation is not documented in this Betting API section, the server does not expose it either — it has no tools beyond these specs.

Example

Once connected, ask your AI tool things like:

  • "What specs does this server know about, and who implements each one?" — calls get_contract with no arguments.
  • "Show me the request schema for POST /bet/place." — calls get_contract with the spec and operation.
  • "What callbacks do I need to implement, and what do they expect back?" — calls list_callback_endpoints.
  • "Give me an example payload for the cash out callback." — calls build_callback_fixture.
  • "What sports and markets does the Betting API support?" — pulls from Dictionaries.
  • "Create a €10 freebet for player 12345, valid for 7 days." — calls the Free Bet API.
  • "Show me yesterday's bet report." — calls Bet Reports.
  • "Cancel bet #98765." — calls Bet Actions.
  • "What's player 12345's risk score?" — calls Player risk scores.
  • "Generate a demo session token in EUR." — calls Token.

The assistant picks the right tool, fills in the request from the conversation, and shows you the response — you can inspect it, adjust the request, or ask a follow-up.

Prerequisites

You need a client_id / client_secret pair for your white label. Create one yourself in the Betting Backoffice — see OAuth2 Credentials.

Connecting

The server is published at:

1
https://mcp.databet.dev/mcp/betting

Open claude_desktop_config.json and add an entry to mcpServers:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
{
  "mcpServers": {
    "databet-sportsbook-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.databet.dev/mcp/betting"
      ]
    }
  }
}

Restart Claude Desktop to pick up the change.

1
claude mcp add databet-sportsbook-mcp -- npx -y mcp-remote https://mcp.databet.dev/mcp/betting

Any client that can spawn a local MCP server process can connect the same way — configure it to run:

1
npx -y mcp-remote https://mcp.databet.dev/mcp/betting

A client with native support for remote (HTTP) MCP servers can instead connect directly to the URL above, without mcp-remote.

Authorizing

On first connection, mcp-remote opens a browser tab to a page titled Authorize API access, with two fields — Client ID and Client Secret. Enter the credentials from Prerequisites and click Authorize. The tool then stores a refresh token, so you will not be asked to authorize again until the token expires or is revoked.

If revoking a client_id / client_secret in the Betting Backoffice, disconnect and reconnect the tool afterward — see Revoking a credential.

Backend integration

Token and session management

The first step on your backend side is the ability to generate betting tokens for your users' sessions. You can Heartbeat Callback API to manage your sessions.

For more details about token generation, session lifecycle management, and typical session flow, refer to the Token documentation.

Bet Callback API

The Bet API is the core integration component that must be implemented on the client side. This component handles the critical betting callbacks and interactions.

For more details, refer to the Bet documentation.

Optional integrations

The following features are optional but commonly implemented by partners:

Free Bets and Bet Insurance are bonus mechanics. Partners usually integrate these into their gamification or bonus engine (e.g., welcome bonuses, achievement rewards, tournament prizes, etc.).

To create bonuses, you need access to dictionary entities (sports, leagues, markets, etc.) to specify your bonus conditions. For more details, refer to the Dictionary API.

Admin use cases: Bet Actions API

Partners may want to:

  • Fetch betting history for their admin panels.
  • Cancel or void specific bets manually.

For that purpose, the following Bet Actions is provided

Callback server requirements

Once you're ready to start receiving heartbeat/bet callbacks, provide your callback server URL.

Tip

You can find a simple example of how to develop your own callback server using Node.js in the GitHub repository databet-cloud/callback-server-example. It utilizes every type and callback described within the Bet Swagger specification page.

Frontend integration

Once you are able to create a valid betting token, you can embed the SPA directly into your website with the default view.

Quick start

For testing, you can even create a token using a simple curl command.

For production, your backend must generate and manage per-user tokens.

Adding the bootstrap script

To initialize the SPA, include the bootstrap script on your page.

For more details, refer to the Integration Bootstrap Script section.

This script loads the application and handles communication with the backend.

Add required DOM containers

You'll need to add specific DOM containers where different SPA components will be rendered.

For instructions, refer to the SPA Integration section.

After adding the containers and calling the bootstrap logic with the generated token, the SPA will be fully embedded and functional.

Customization of layout, routes, theme and widgets

For customization of layout, routes, theme and widgets, the Data.Bet team will be able to guide you through the process.

Integration testing before go-live

Before go-live, a mandatory integration testing phase will be run.