Types

Adapter Object

Property	Type	Required	Description
config	ConfigObject		Adapter configuration settings
endpoints	EndpointsObject	yes	Adapter endpoint implementations

Config Object

The config object controls adapter behavior and widget-specific configurations.

Property	Type	Required	Description
widget	WidgetConfig		Widget-specific configurations

WidgetConfig

Property	Type	Required	Description
'betRecommendation.eventList'	BrEventListConfig		Configuration for bet recommendation event list widget

Endpoints Object

The endpoints object contains all adapter endpoint implementations.

The market and eventMarkets endpoints are mutually exclusive – you only need to implement ONE of these two. Choose based on your API capabilities:

• Implement market if your API can fetch a specific market for an event efficiently

• Implement eventMarkets if your API can fetch all markets for an event in a single call

• If implementing market, you can optionally add availableMarketsForEvent to list available markets first

Shared Endpoints Across Widgets: All widgets use the same adapter endpoints. When a specific widget needs to limit returned data, the request args will include a widget property containing the widget name (the same value used in SIR('addWidget', widgetName, ...)). Use this to conditionally filter or modify your response per widget if needed.

Property	Type	Required	Description
availableMarketsForEvent	AvailableMarketsForEventFunction		Retrieves all available markets selections for a specific event. Use with market endpoint to discover available markets.
market	MarketFunction		Implement either this OR eventMarkets – Retrieves a specific market data for a specific event.
eventMarkets	EventMarketsFunction		Implement either this OR market – Retrieves all markets data for a specific event in one call. Use if your API provides all markets on one endpoint.
event	EventFunction		Retrieves detailed event data including event start time, scores, team names, tournament name, and more.
filterMarkets	FilterMarketsFunction		Filters available markets based on widget requirements and provided selections, returning all or a subset.
betSlipSelection	BetSlipSelectionFunction		Subscribes to the current punter's bet slip selections (their betting cart)
cashBackSelections	CashBackSelectionsFunction		Retrieves selections eligible for cash back promotions.
tickets	TicketsFunction		Retrieves the punter's placed bets (tickets)

// Example adapter implementation
const adapter = {
  config: {
    widget: {
      'betRecommendation.eventList': {
        layout: { /* EventListMarketsConfig */ },
        allowedMarkets: { /* SportMarketsMap */ }
      }
    }
  },
  endpoints: {
    event: (args, callback) => {
      // Fetch and return event data
      // Return optional unsubscribe function
    },
    eventMarkets: (args, callback) => {
      // Fetch and return markets for event
    },
    market: (args, callback) => {
      // Fetch and return specific market
    }
    // ... other endpoints
  }
};

Adapter Endpoints

Market Function

Retrieves data for a specific market of a specific event.

The market and eventMarkets endpoints are mutually exclusive – you only need to implement ONE. If your API does not support fetching individual markets, consider using the eventMarkets endpoint instead.

Names such as market names, outcome names, and other text content should be provided in the language specified by args.language to ensure proper localization for users.

The oddsType parameter specifies the current format of odds set for the widget. If you provide odds in a different format, consider updating the odds type in the widget loader configuration. See the Widget Loader documentation for details on configuring odds formats.

Argument	Type	Required	Description
args	MarketRequest	yes	Request parameters including market/outcome selection, language, and odds type
callback	Callback<MarketResponse>	yes	Function to receive market data or error

Returns: UnsubscribeFunction - Optional cleanup function to stop receiving updates

// Example implementation
adapter.endpoints.market = (args, callback) => {
  // args example:
  // {
  //   selection: { event: "sr:match:123", market: "18", specifiers: "total=2.5", type: 'uf' },
  //   language: "en",
  //   oddsType: "eu"
  // }
  
  // Your implementation here - fetch specific market data based on args
  // Then call callback with the result
  callback(undefined, {
    market: {
    id: "1",
    name: "Match Winner (1X2)",
    outcomes: [
      { id: "1", name: "Home", status: "active", odds: { type: "eu", value: "2.10" } },
      { id: "X", name: "Draw", status: "active", odds: { type: "eu", value: "3.40" } },
      { id: "2", name: "Away", status: "active", odds: { type: "eu", value: "3.50" } }
    ],
    status: "active"
  },
    event: { id: "sr:match:12345", type: "uf" }
  });
  
  // Return optional unsubscribe function
  return () => {
    // Cleanup subscriptions if needed
  };
};

EventMarkets Function

Retrieves data for all markets of a specific event.

The eventMarkets and market endpoints are mutually exclusive – you only need to implement ONE. If your API does not support fetching all markets for requested event, consider using the market endpoint instead.

Names such as market names, outcome names, and other text content should be provided in the language specified by args.language to ensure proper localization for users.

The oddsType parameter specifies the current format of odds set for the widget. If you provide odds in a different format, consider updating the odds type in the widget loader configuration. See the Widget Loader documentation for details on configuring odds formats.

Argument	Type	Required	Description
args	EventMarketsRequest	yes	Request parameters including event selection, language, and odds type
callback	Callback<EventMarketsResponse>	yes	Function to receive markets data or error

Returns: UnsubscribeFunction - Optional cleanup function to stop receiving updates

// Example implementation
adapter.endpoints.eventMarkets = (args, callback) => {
  // args example:
  // {
  //   selection: { event: "sr:match:12345", type: "uf" },
  //   language: "en",
  //   oddsType: "eu"
  // }
  
  // Your implementation here - fetch markets data based on args
  // Then call callback with the result
  callback(undefined, {
    markets: [
       {
        id: "18",
        name: "Total Goals",
        specifiers: "total=2.5",
        outcomes: [
          { id: "12", name: "Over 2.5", status: "active", odds: { type: "eu", value: "1.85" } },
          { id: "13", name: "Under 2.5", status: "active", odds: { type: "eu", value: "2.05" } }
        ],
        status: "active"
      },
      // ... other of market objects ofr this event
    ],
    event: args.selection.id
  });
  
  // Return optional unsubscribe function
  return () => {
    // Cleanup subscriptions if needed
  };
};

Event Function

Retrieves detailed event data including event start time, scores, team names, tournament name, and more.

Names such as team names, tournament names, and other text content should be provided in the language specified by args.language. Event times should be converted and displayed in the timezone specified by args.displayedTimezone to ensure proper localization for users.

Argument	Type	Required	Description
args	EventRequest	yes	Request parameters including event selection and display preferences
callback	Callback<EventResponse>>	yes	Function to receive event data or error

Returns: UnsubscribeFunction - Optional cleanup function to stop receiving updates

// Example implementation
adapter.endpoints.event = (args, callback) => {
  // args example:
  // {
  //   selection: { event: "sr:match:12345", type: "uf" },
  //   language: "en",
  //   displayedTimezone: "Europe:Berlin"
  // }
  
  // Your implementation here - fetch event data based on args
  // Then call callback with the result
  callback(undefined, {
    event: {
      id: args.selection.id,
      // ... other event properties
    }
  });
  
  // Return optional unsubscribe function
  return () => {
    // Cleanup subscriptions if needed
  };
};

AvailableMarketsForEvent Function

Retrieves all available market offering in Selection format for a requested event.

Argument	Type	Required	Description
args	AvailableMarketsForEventRequest	yes	Request parameters including event selection
callback	Callback<AvailableMarketsForEventResponse>	yes	Function to receive available markets or error

Returns: UnsubscribeFunction - Optional cleanup function to stop receiving updates

// Example implementation
adapter.endpoints.availableMarketsForEvent = (args, callback) => {
  // args example:
  // {
  //   selection: { event: "sr:match:12345", type: "uf" }
  // }
  
  // Your implementation here - fetch available markets for the event
  // Then call callback with the result
  callback(undefined, {
    selection: [
      { event: "sr:match:12345", market: "1", type: "uf" },
      { event: "sr:match:12345", market: "18", specifiers: "total=1.5" type: "uf" },
      { event: "sr:match:12345", market: "18", specifiers: "total=2.5" type: "uf" },
      // ... other market offering selections
    ]
  });
  
  // Return optional unsubscribe function
  return () => {
    // Cleanup subscriptions if needed
  };
};

FilterMarkets Function

This endpoint is called to perform additional filtering based on widget-specific requirements or other parameters. The widget property in the request arguments identifies which widget is requesting the filtering, allowing you to customize market filtering logic per widget. If no filtering is required, you can simply return the input selections unchanged. Example: For Swipe Bet you only want to use market 1x2 out of all available.

Argument	Type	Required	Description
args	FilterMarketsRequest	yes	Request parameters including widget name and optional event selections
callback	Callback<FilterMarketsResponse>	yes	Function to receive filtered markets or error

Returns: UnsubscribeFunction - Optional cleanup function to stop receiving updates

// Example implementation
adapter.endpoints.filterMarkets = (args, callback) => {
  // args example:
  // {
  //   widget: "swipeBet",
  //   selection: [
  //     { event: "sr:match:12345", type: "uf", market: "1" },
  //     { event: "sr:match:12345", type: "uf", market: "18", specifiers: "total=2.5" }
  //   ]
  // }
  
  // Your implementation here - filter markets based on widget and selections
  // Then call callback with the result
  // callback(undefined, {
  //   selection: [
  //     { market: "sr:match:12345", type: "uf", market: "1" },
  //     // ... filtered selections
  //   ]
  // });

  // Or just return the selection if you don't wish to filter
  callback(undefined, {
    selection: args.selection
  });
  
  // Return optional unsubscribe function
  return () => {
    // Cleanup subscriptions if needed
  };
};

BetSlipSelection Function

Subscribes to the current punter's bet slip selections (their betting cart). Widgets use this data to display selections as selected or, depending on the widget, may hide certain selections.

Argument	Type	Required	Description
args	undefined		No arguments
callback	Callback<BetSlipSelectionResponse>	yes	Function to receive bet slip selections or error

Returns: UnsubscribeFunction - Optional cleanup function to stop receiving updates

// Example implementation
adapter.endpoints.betSlipSelection = (args, callback) => {
  // args is undefined for this endpoint
  
  // Your implementation here - subscribe to bet slip changes
  // Call callback whenever bet slip changes
  callback(undefined, {
    selection: [
      { event: "sr:match:12345", market: "1", outcome: "2", odds: { type: "eu", value: "1.95" } },
      // ... current bet slip selections
    ]
  });
  
  // Return unsubscribe function to stop receiving updates
  return () => {
    // Cleanup bet slip subscription
  };
};

CashBackSelections Function

Retrieves selections eligible for cash back promotions.

Argument	Type	Required	Description
args	CashBackSelectionsRequest	yes	Request parameters including widget name and event selections
callback	Callback<CashBackSelectionsResponse>	yes	Function to receive cash back selections or error

Returns: UnsubscribeFunction - Optional cleanup function to stop receiving updates

// Example implementation
adapter.endpoints.cashBackSelections = (args, callback) => {
  // args example:
  // {
  //   widget: "cashBack",
  //   selection: [
  //     { event: "sr:match:12345", type: "uf" },
  //     { event: "sr:match:67890", type: "uf" }
  //   ]
  // }
  
  // Your implementation here - fetch cash back eligible events
  // Then call callback with the result
  callback(undefined, {
    events: [
      { event: "sr:match:12345", type: "uf" },
      // ... events eligible for cash back
    ]
  });
  
  // Return optional unsubscribe function
  return () => {
    // Cleanup subscriptions if needed
  };
};

Tickets Function

Retrieves the punter's placed bets (tickets).

Argument	Type	Required	Description
args	TicketsRequest	yes	Request parameters including operator ID, customer ID, and optional filters
callback	Callback<TicketsResponse>	yes	Function to receive tickets or error

Returns: UnsubscribeFunction - Optional cleanup function to stop receiving updates

// Example implementation
adapter.endpoints.tickets = (args, callback) => {
  // args example:
  // {
  //   operatorId: "operator123",
  //   endCustomerId: "customer456",
  //   events: [
  //     { id: "sr:match:12345", type: "uf" }
  //   ],
  //   channelId: "web",
  //   page: 1
  // }
  
  // Your implementation here - fetch user tickets based on args
  // Then call callback with the result
  callback(undefined, {
    tickets: [
      // array of ticket objects
    ]
  });
  
  // Return optional unsubscribe function
  return () => {
    // Cleanup subscriptions if needed
  };
};

Utility Types

Callback<T>

Error-first callback function pattern used by all adapter endpoints.

Property	Type	Required	Description
error	Error | undefined	yes	Error object if the operation failed, or undefined if successful
data	T | undefined		Response data if successful, or undefined if an error occurred

Type Parameters:

• T - The type of data returned on success

// Type-specific example with BetSlipSelectionResponse
betSlipSelection(args, callback) {
  // other code
  
  if (error) {
    // something went wrong, return error
    callback(error)
    return;
  }
  // Operation successful, return BetSlipSelectionResponse
  callback(undefined, { selection: { event: "sr:match:12345", market: "18", outcome: "1", odds: { type: "uk", value: "3.2", numerator: "6", denominator: "4" }} })

  // rest of code
}

UnsubscribeFunction

Optional cleanup function returned by adapter endpoints to stop receiving updates.

Type: (() => void) | undefined

When an adapter endpoint returns an UnsubscribeFunction, you can call it to stop receiving further callback invocations. This is useful for:

• Cleaning up subscriptions when a component unmounts

• Stopping live data updates when they are no longer needed

• Managing memory and preventing memory leaks

endpoint(args, callback) {
  // code
  return () => {
    // Implement unsubscribe logic, e.g., remove event listener, cancel subscription
    subscription.unsubscribe();
  }
}

See Also: Callback<T>

Request Types

EventRequest

Request parameters for fetching event data.

Property	Type	Required	Description
selection	SelectionEvent	yes	Event identifier in UF or external format
language	string		Language code for localized content (e.g., "en", "de")
displayedTimezone	string		Timezone for displaying event times (e.g., "Europe:Berlin", "Europe/London")

// Example usage
const eventRequest = {
  selection: { event: "sr:match:12345", type: "uf" },
  language: "en",
  displayedTimezone: "Europe:Berlin"
};

// With minimal properties
const minimalRequest = {
  selection: { event: "sr:match:67890", type: "uf" }
};

EventMarketsRequest

Request parameters for fetching all markets data for a specific event.

Property	Type	Required	Description
selection	SelectionEvent	yes	Event identifier in UF or external format
language	string		Language code for localized content (e.g., "en", "de")
oddsType	string		Type of odds to display. Valid values: 'eu', 'uk', 'us', 'hong-kong', 'indonesian', 'malay'

// Example usage
const eventMarketsRequest = {
  selection: { id: "sr:match:12345", type: "uf" },
  language: "en",
  oddsType: "eu"
};

// With minimal properties
const minimalRequest = {
  selection: { id: "sr:match:67890", type: "uf" }
};

MarketRequest

Request parameters for fetching a specific market data for an event.

Property	Type	Required	Description
selection	SelectionMarket | SelectionOutcome	yes	Market or outcome identifier to fetch
language	string	yes	Language code for localized content (e.g., "en", "de")
oddsType	string	yes	Type of odds to display. Valid values: 'eu', 'uk', 'us', 'hong-kong', 'indonesian', 'malay'

// Example usage with market selection
const marketRequest = {
  selection: { id: "sr:market:123", marketId: 1 },
  language: "en",
  oddsType: "eu"
};

// Example with outcome selection
const outcomeRequest = {
  selection: { id: "sr:outcome:456", outcomeId: "1" },
  language: "en",
  oddsType: "us"
};

AvailableMarketsForEventRequest

Request parameters for fetching all available markets for a specific event.

Property	Type	Required	Description
selection	SelectionEvent	yes	Event identifier in UF or external format

// Example usage
const availableMarketsRequest = {
  selection: { event: "sr:match:12345", type: "uf" }
};

FilterMarketsRequest

Request parameters for filtering markets based on widget configuration.

Property	Type	Required	Description
widget	string	yes	Widget identifier to determine which markets to filter (e.g., "swipeBet", "betRecommendation")
selection	SelectionMarket[]		Optional array of market identifiers to filter markets

// Example usage with events
const filterMarketsRequest = {
  widget: "swipeBet",
  selection: [
    { id: "sr:match:12345", type: "uf", market: "1" },
    { id: "sr:match:67890", type: "uf", market: "18", specifiers: "total=2.5" }
  ]
};

// Example with widget only
const simpleRequest = {
  widget: "betRecommendation"
};

TicketsRequest

Request parameters for fetching tickets.

Property	Type	Required	Description
operatorId	string	yes	Client/operator identifier
endCustomerId	string	yes	End user/customer identifier
events	SelectionEvent[]		Optional array of event identifiers to filter tickets by specific events
channelId	string		Optional channel identifier to filter tickets by virtual stadium chat channel
page	number		Optional page number for pagination

// Example usage with all properties
const ticketsRequest = {
  operatorId: "operator123",
  endCustomerId: "customer456",
  events: [
    { id: "sr:match:12345", type: "uf" }
  ],
  channelId: "euro-league",
  page: 1
};

// Example with minimal properties
const minimalRequest = {
  operatorId: "operator123",
  endCustomerId: "customer456"
};

Response Types

EventResponse

Response data containing event information.

Property	Type	Required	Description
event	Event	yes	Complete event data including details, status, participants, and metadata

// Example response structure
const eventResponse = {
  event: {
    id: "sr:match:12345",
    sport: { id: "1", name: "Soccer" },
    category: { id: "1", name: "England" },
    tournament: { id: "17", name: "Premier League" },
    teams: [
      { id: "sr:team:1", name: "Manchester United" },
      { id: "sr:team:2", name: "Liverpool" }
    ],
    isLive: false,
    // ... additional event properties
  }
};

EventMarketsResponse

Response data containing all markets for an event.

Property	Type	Required	Description
markets	Market[]	yes	Array of market data for the event
event	string	yes	Event identifier string (e.g., "sr:match:12345")

// Example response structure
const eventMarketsResponse = {
  markets: [
     {
      id: "18",
      name: "Total Goals",
      specifiers: "total=2.5",
      outcomes: [
        { id: "12", name: "Over 2.5", status: "active", odds: { type: "eu", value: "1.85" } },
        { id: "13", name: "Under 2.5", status: "active", odds: { type: "eu", value: "2.05" } }
      ],
      status: "active"
    },
    // ... additional markets
  ],
  event: { id: "sr:match:12345", type: "uf" }
};

MarketResponse

Response data containing a specific market and event information.

Property	Type	Required	Description
market	Market	yes	Market data including outcomes and odds
event	string	yes	Event identifier string (e.g., "sr:match:12345")

// Example response structure
const marketResponse = {
  market: {
    id: "sr:market:1",
    name: "Match Winner",
    outcomes: [
      { id: "1", name: "Home", odds: 2.5 },
      { id: "X", name: "Draw", odds: 3.0 },
      { id: "2", name: "Away", odds: 3.2 }
    ]
  },
  event: { id: "sr:match:12345", type: "uf" }
};

AvailableMarketsForEventResponse

Response data containing all available market offering as selections for an event.

Property	Type	Required	Description
selection	SelectionMarket[]	yes	Array of market selection identifiers available for the event

// Example response structure
const availableMarketsResponse = {
  selection: [
    { event: "sr:event:1", market: "1" },
    { event: "sr:event:2", market: "18", specifiers: "total=2.5" },
    { event: "sr:event:3", market: "10" }
  ]
};

FilterMarketsResponse

Response data containing filtered market selections based on the widget identifier and input selections.

Property	Type	Required	Description
selection	SelectionMarket[]	yes	Array of event or market selections that match the filter criteria

// Example response structure
const filterMarketsResponse = {
  selection: [
    { event: "sr:match:12345", type: "uf", market: "1" },
    { event: "sr:match:12345", type: "uf", market: "18", specifiers: "total=2.5" }
  ]
};

BetSlipSelectionResponse

Response data containing currently selected outcomes in the bet slip.

Property	Type	Required	Description
selection	SelectionOutcome[]	yes	Array of outcome selections currently in the bet slip

// Example response structure
const betSlipSelectionResponse = {
  selection: [
    { event: "sr:match:12345", market: "1", outcome: "2", odds: { type: "eu", value: "1.95" } },
    { event: "sr:match:12345", market: "18", outcome: "1", odds: { type: "uk", value: "3.2", numerator: "6", denominator: "4" }}    
  ]
};

CashBackSelectionsRequest

Request parameters for fetching cash back selections.

Property	Type	Required	Description
widget	string	yes	Widget identifier to determine the context of the cash back request
selection	SelectionEvent[]	yes	Array of event selections to check for cash back eligibility

// Example usage
const cashBackSelectionsRequest = {
  widget: "cashBack",
  selection: [
    { event: "sr:match:12345", type: "uf" },
    { event: "sr:match:67890", type: "uf" }
  ]
};

CashBackSelectionsResponse

Response data containing events eligible for cash back.

Property	Type	Required	Description
events	SelectionEvent[]	yes	Array of event selections that are eligible for cash back promotions

// Example response structure
const cashBackSelectionsResponse = {
  events: [
    { id: "sr:match:12345", type: "uf" },
    { id: "sr:match:67890", type: "uf" }
  ]
};

TicketsResponse

Response data containing user tickets.

Property	Type	Required	Description
tickets	Ticket[]	yes	Array of ticket objects containing bet information, status, and outcomes

// Example response structure
const ticketsResponse = {
  tickets: [
    {
      ticketId: "ticket_123456",
      bets: [
        {
          betId: "bet_001",
          selections: [
            {
              type: "uf",
              event: "sr:match:12345",
              market: "1",
              outcome: "1",
              odds: { type: "eu", value: "2.10" }
            }
          ],
          stake: [{
            type: "cash",
            currency: "USD",
            amount: "10.00",
            mode: "total"
          }]
        }
      ],
      type: "ticket",
      version: "1.0"
    }
    // ... additional tickets
  ]
};

Adapter Data Types

SelectionEvent

Discriminated union type for identifying betting events. The type field discriminates between UF (Unified Feed) and external formats.

When type: 'uf'

Use this format when referencing events from the Sportradar Unified Feed (UOF).

Property	Type	Required	Description
type	'uf'	yes	Indicates Unified Feed format
event	string	yes	SR entity identifier following UOF schema (e.g., "sr:match:12345", "sr:stage:67890")

When type: 'external'

Use this format when referencing events using your own client-defined identifiers.

Property	Type	Required	Description
type	'external'	yes	Indicates external client-defined format
event	string	yes	Client-defined unique event identifier. Format is determined by your system (e.g., "736977", "event_12345")

// UF format - referencing a Sportradar match
const ufSelection = {
  type: "uf",
  event: "sr:match:12345"
};

// External format - referencing a client-defined event
const externalSelection = {
  type: "external",
  event: "ext:match:736977"
};

See Also: SelectionMarket, SelectionOutcome

SelectionMarket

Discriminated union type for identifying betting markets within events. Extends SelectionEvent with market-specific properties. The type field discriminates between UF (Unified Feed) and external formats.

When type: 'uf'

Use this format when referencing markets from the Sportradar Unified Feed (UOF).

Property	Type	Required	Description
type	'uf'	yes	Indicates Unified Feed format
event	string	yes	SR entity identifier following UOF schema (e.g., "sr:match:12345")
market	string	yes	Betting market identifier as defined by UOF. Retrieved from the UOF feed (e.g., "1" for 1x2)
specifiers	string		Additional market data as defined by UOF. Although optional in schema, must be provided when the UOF market requires specifiers (e.g., for "Total 1.5" vs "Total 2.5", specifiers would be "total=1.5")

When type: 'external'

Use this format when referencing markets using your own client-defined identifiers.

Property	Type	Required	Description
type	'external'	yes	Indicates external client-defined format
event	string	yes	Client-defined unique event identifier
market	string	yes	Client-defined market identifier. If not available in your system, use the outcome identifier

// UF format - referencing a Sportradar market
const ufMarket = {
  type: "uf",
  event: "sr:match:12345",
  market: "1"
};

// UF format with specifiers - market with line (e.g., Total goals)
const ufMarketWithSpecifiers = {
  type: "uf",
  event: "sr:match:12345",
  market: "18",
  specifiers: "total=2.5"
};

// External format - client-defined market
const externalMarket = {
  type: "external",
  event: "event_12345",
  market: "match_winner"
};

See Also: SelectionEvent, SelectionOutcome

SelectionOutcome

Discriminated union type for identifying specific betting outcomes within markets. Extends SelectionMarket with outcome-specific properties. The type field discriminates between UF (Unified Feed) and external formats.

When type: 'uf'

Use this format when referencing outcomes from the Sportradar Unified Feed (UOF).

Property	Type	Required	Description
type	'uf'	yes	Indicates Unified Feed format
event	string	yes	SR entity identifier following UOF schema (e.g., "sr:match:12345")
market	string	yes	Betting market identifier as defined by UOF
specifiers	string		Additional market data as defined by UOF. Required when market uses specifiers
outcome	string	yes	Market outcome identifier as defined by UOF. Retrieved from the UOF feed (e.g., "1" for home win in 1x2 market)
odds	Odds		Odds information for this outcome

When type: 'external'

Use this format when referencing outcomes using your own client-defined identifiers.

Property	Type	Required	Description
type	'external'	yes	Indicates external client-defined format
event	string	yes	Client-defined unique event identifier
market	string	yes	Client-defined market identifier
outcome	string	yes	Client-defined unique market outcome identifier
odds	Odds	yes	Odds information for this outcome (required for external format)

// UF format - referencing a Sportradar outcome
const ufOutcome = {
  type: "uf",
  event: "sr:match:12345",
  market: "1",
  outcome: "1",
  odds: {
    type: "eu",
    value: "2.50"
  }
};

// UF format with specifiers
const ufOutcomeWithSpecifiers = {
  type: "uf",
  event: "sr:match:12345",
  market: "18",
  specifiers: "total=2.5",
  outcome: "12",
  odds: {
    type: "eu",
    value: "1.85"
  }
};

// External format - client-defined outcome
const externalOutcome = {
  type: "external",
  event: "event_12345",
  market: "match_winner",
  outcome: "home",
  odds: {
    type: "eu",
    value: "2.10"
  }
};

See Also: SelectionEvent, SelectionMarket, Odds

Odds

Represents betting odds in various formats with optional custom display values.

Property	Type	Required	Description
type	string	yes	Odds format. Valid values: 'eu' (European/Decimal), 'uk' (UK/Fractional), 'us' (American)
value	string	yes	Odds value submitted by the client. Pattern: 1-8 digits (first cannot be 0), optionally followed by decimal point and 1-8 digits. Regex: ^[1-9]\d{0,7}(\.\d{1,8})?$
numerator	string		Numerator of fractional odds. Only present when type is 'uk' (fractional). Regex: ^[1-9]\d{0,7}$
denominator	string		Denominator of fractional odds. Only present when type is 'uk' (fractional). Regex: ^[1-9]\d{0,7}$
customDisplayValue	string		Custom display value for odds, used as-is for display purposes. Only provide if you want to handle custom formatting

// European (decimal) odds
const decimalOdds = {
  type: "eu",
  value: "2.50"
};

// UK (fractional) odds
const fractionalOdds = {
  type: "uk",
  value: "3.2",
  numerator: "6",
  denominator: "4"
};

// American odds
const americanOdds = {
  type: "us",
  value: "150"
};

// With custom display value
const customOdds = {
  type: "eu",
  value: "2.50",
  customDisplayValue: "5/2"
};

Outcome

Represents a single betting outcome within a market.

Property	Type	Required	Description
id	string	yes	Unique identifier for the outcome, used to reference it in bets
name	string	yes	Translated name of the outcome, used for display purposes
competitor	string		Name or identifier of the team or player associated with this outcome. Useful for markets where each outcome is tied to a specific competitor (e.g., for 1x2 market, outcome: 1, competitor: "FC Barca")
odds	Odds		Odds information for this outcome
status	string	yes	Outcome status. Valid values: 'active', 'inactive'

// Active outcome with odds
const outcome = {
  id: "1",
  name: "Home Win",
  competitor: "FC Barcelona",
  odds: {
    type: "eu",
    value: "2.50"
  },
  status: "active"
};

// Inactive outcome
const inactiveOutcome = {
  id: "X",
  name: "Draw",
  status: "inactive"
};

See Also: Market, Odds

Market

Represents a betting market with multiple outcomes.

Property	Type	Required	Description
id	string	yes	Unique identifier for the market, used to reference it in bets
name	string	yes	Translated name of the market, used for display purposes
outcomes	Outcome[]	yes	All outcomes associated with this market
status	string	yes	Market status. Valid values: 'active', 'deactivated', 'suspended', 'settled', 'cancelled'
specifiers	string		Additional market data as defined by UOF (e.g., for markets with lines like Total 1.5 vs Total 2.5). Although optional in schema, must be provided when the UOF market requires specifiers

Market Status Values:

• active: Odds are provided and you can accept bets on the market

• deactivated: Odds are no longer provided for this market. Can go back to active (e.g., when a different total line becomes most balanced)

• suspended: Odds continue to be provided but you should not accept bets temporarily (e.g., "bet stop" before/during goal confirmation)

• settled: Bet settlement messages have been sent for this market, no further odds will be provided. In rare cases, settled markets may be moved to cancelled

• cancelled: This market has been cancelled. No further odds will be provided

// Active market with outcomes
const market = {
  id: "1",
  name: "Match Winner (1X2)",
  outcomes: [
    { id: "1", name: "Home", status: "active", odds: { type: "eu", value: "2.10" } },
    { id: "X", name: "Draw", status: "active", odds: { type: "eu", value: "3.40" } },
    { id: "2", name: "Away", status: "active", odds: { type: "eu", value: "3.50" } }
  ],
  status: "active"
};

// Market with specifiers (Total goals)
const totalMarket = {
  id: "18",
  name: "Total Goals",
  specifiers: "total=2.5",
  outcomes: [
    { id: "12", name: "Over 2.5", status: "active", odds: { type: "eu", value: "1.85" } },
    { id: "13", name: "Under 2.5", status: "active", odds: { type: "eu", value: "2.05" } }
  ],
  status: "active"
};

See Also: Outcome, Event

Event

Represents a sporting event with teams, tournament information, and match details.

Property	Type	Required	Description
id	string	yes	Event identifier as defined by UOF. Retrieved from the MAPI feed
sport	Sport	yes	Sport information (imported from adapter types)
category	Category	yes	Category information (e.g., country, region)
tournament	Tournament	yes	Tournament information
teams	[Team, Team]	yes	Array of exactly two teams (home and away)
isLive	boolean	yes	Indicates whether the event is currently live
date	EventDate		Date information for the event
date.displayValue	string		Formatted date string for display
date.startTime	string		Event start time (ISO format)
liveCurrentTime	string		Current match time for live events (e.g., "45:00", "HT")
result1	Result		Primary result/score information
result2	Result		Secondary result information (e.g., half-time score)
result3	Result		Tertiary result information (e.g., period scores)

// Pre-match event
const prematchEvent = {
  id: "sr:match:12345",
  sport: { id: "1", name: "Soccer" },
  category: { id: "1", name: "England" },
  tournament: { id: "17", name: "Premier League" },
  teams: [
    { id: "sr:team:1", name: "Manchester United" },
    { id: "sr:team:2", name: "Liverpool" }
  ],
  isLive: false,
  date: {
    displayValue: "Jan 7, 2026",
    startTime: "2026-01-07T20:00:00Z"
  }
};

// Live event with score
const liveEvent = {
  id: "sr:match:67890",
  sport: { id: "1", name: "Soccer" },
  category: { id: "1", name: "England" },
  tournament: { id: "17", name: "Premier League" },
  teams: [
    { id: "sr:team:3", name: "Chelsea" },
    { id: "sr:team:4", name: "Arsenal" }
  ],
  isLive: true,
  liveCurrentTime: "72:15",
  result1: { home: 2, away: 1 }
};

See Also: Market, SelectionEvent

EventDate

Represents date and time information for an event.

Property	Type	Required	Description
displayValue	string		Formatted date string for display purposes
startTime	string		Event start time in ISO format (e.g., "2026-01-07T20:00:00Z")

// Example date object
const eventDate = {
  displayValue: "Jan 7, 2026",
  startTime: "2026-01-07T20:00:00Z"
};

See Also: Event

Ticket

Represents a betting ticket containing one or more bets.

Property	Type	Required	Description
ticketId	string	yes	Client defined string to identify the ticket (unique in the client's system),
minimal string length = 1,
maximum string length = 128
bets	Bet[]	yes	Array of bets included in this ticket
type	'ticket'	yes	Declaration of content type, should be "ticket"
version	1.0	yes	Ticket format version

const ticket = {
  ticketId: "ticket_123456",
  bets: [
    {
      betId: "bet_001",
      selections: [
        {
          type: "uf",
          event: "sr:match:12345",
          market: "1",
          outcome: "1",
          odds: { type: "eu", value: "2.10" }
        }
      ],
      stake: [{
        type: "cash",
        currency: "USD",
        amount: "10.00",
        mode: "total"
      }]
    }
  ],
  type: "ticket",
  version: "1.0"
};

See Also: Bet, TicketsResponse

Bet

Represents a single bet within a ticket, containing selections and stake information.

Property	Type	Required	Description
betId	string	yes	Unique bet id (in the client's system),
minimal string length = 1,
maximum length = 128
selections	Array<TicketSelection | SelectionOutcome>	yes	Array of bet selections, included in this bet. Can include custom bets (TicketSelection) or standard outcomes (SelectionOutcome)
minimal number of selections per bet = 1,
maximum number = 100
stake	Array<Stake>	yes	Array of bet stakes,
minimal number of stake per bet = 1,
maximum number = 5
odds	Odds		The odds for this bet

// Single bet
const singleBet = {
  betId: "bet_001",
  selections: [
    {
      type: "uf",
      event: "sr:match:12345",
      market: "1",
      outcome: "1",
      odds: { type: "eu", value: "2.10" }
    }
  ],
  stake: [{
    type: "cash",
    currency: "USD",
    amount: "10.00"
  }]
};

// Accumulator bet
const accumulatorBet = {
  betId: "bet_002",
  selections: [
    {
      type: "uf",
      event: "sr:match:12345",
      market: "1",
      outcome: "1",
      odds: { type: "eu", value: "2.10" }
    },
    {
      type: "uf",
      event: "sr:match:67890",
      market: "1",
      outcome: "1",
      odds: { type: "eu", value: "1.85" }
    }
  ],
  stake: [{
    type: "cash",
    currency: "USD",
    amount: "5.00"
  }],
  odds: { type: "eu", value: "3.89" }
};

// Custom bet using TicketSelection
const customBet = {
  betId: "bet_003",
  selections: [
    {
      type: "custom-bet",
      betId: "custom_001",
      selections: [
        {
          type: "uf",
          event: "sr:match:12345",
          market: "1",
          outcome: "1",
          odds: { type: "eu", value: "2.10" }
        },
        {
          type: "uf",
          event: "sr:match:12345",
          market: "18",
          specifiers: "total=2.5",
          outcome: "12",
          odds: { type: "eu", value: "1.85" }
        }
      ],
      odds: { type: "eu", value: "3.89" }
    }
  ],
  stake: [{
    type: "cash",
    currency: "EUR",
    amount: "10.00"
  }]
};

See Also: Ticket, SelectionOutcome, TicketSelection, Stake

Stake

Represents stake information for a bet.

Property	Type	Required	Description
type	string	yes	Stake type. Valid values: 'cash' (used for stake and payout), 'bonus' (amount added on top of winnings if bet is won)
currency	string	yes	Currency code (e.g., "USD", "EUR", "GBP")
amount	string	yes	Stake amount as a string to allow for decimal values
mode	string		Stake mode (default: 'total'). Valid values: 'unit' (stake relates to each sub-bet in system bets), 'total' (stake relates to all sub-bets, each receives a portion)

// Cash stake with total mode
const cashStake = {
  type: "cash",
  currency: "USD",
  amount: "10.00",
  mode: "total"
};

// Bonus stake
const bonusStake = {
  type: "bonus",
  currency: "EUR",
  amount: "5.00"
};

// Unit stake for system bet
const unitStake = {
  type: "cash",
  currency: "GBP",
  amount: "2.00",
  mode: "unit"
};

See Also: Bet

TicketSelection

Represents a custom bet selection within a ticket.

Property	Type	Required	Description
type	'custom-bet'	yes	Type identifier, always 'custom-bet'
betId	string		Optional unique identifier for this custom bet
selections	SelectionOutcome[]	yes	Array of outcome selections included in this custom bet
odds	Odds	yes	Odds information for this custom bet

const customBetSelection = {
  type: "custom-bet",
  betId: "custom_001",
  selections: [
    {
      type: "uf",
      event: "sr:match:12345",
      market: "1",
      outcome: "1",
      odds: { type: "eu", value: "2.10" }
    },
    {
      type: "uf",
      event: "sr:match:67890",
      market: "1",
      outcome: "2",
      odds: { type: "eu", value: "1.85" }
    }
  ],
  odds: { type: "eu", value: "3.89" }
};

See Also: Bet, SelectionOutcome

Sport

Represents information about a sport.

Property	Type	Required	Description
id	string		The unique SR identifier for the sport
name	string		The name of the sport
icon	string		URL where the sport icon is located

const soccer = {
  id: "1",
  name: "Soccer",
  icon: "https://example.com/icons/soccer.png"
};

const basketball = {
  id: "2",
  name: "Basketball"
};

See Also: Event, Category

Category

Represents information about a category (e.g., country, region).

Property	Type	Required	Description
id	string		The unique identifier assigned to the category
name	string		The name of the category
cc	object		Country code information
cc.a2	string	yes	Country code in A2 format (if cc object is present)

const england = {
  id: "1",
  name: "England",
  cc: {
    a2: "GB"
  }
};

const spain = {
  id: "32",
  name: "Spain"
};

See Also: Event, Sport

Tournament

Represents information about a tournament.

Property	Type	Required	Description
id	string		The unique identifier assigned to the tournament
externalId	string | number		Your unique identifier for the tournament
name	string		The name of the tournament

const premierLeague = {
  id: "17",
  externalId: "PL2025",
  name: "Premier League"
};

const championsLeague = {
  id: "7",
  name: "UEFA Champions League"
};

See Also: Event, Category

Team

Represents information about a team participating in an event.

Property	Type	Required	Description
id	string		The unique SR identifier assigned to the team
name	string	yes	The name of the team

const manchesterUnited = {
  id: "sr:team:1",
  name: "Manchester United"
};

const liverpool = {
  name: "Liverpool FC"
};

See Also: Event

Result

Represents result/score information for an event.

Property	Type	Required	Description
result	Array<number | string>	yes	The result of the event (e.g., scores, statistics)
label	string		Optional label describing what this result represents

// Match score
const finalScore = {
  result: [2, 1],
  label: "Final Score"
};

// Half-time score
const halftimeScore = {
  result: [1, 0],
  label: "Half-time"
};

// Period scores
const periodScores = {
  result: [25, 20, 30, 18],
  label: "Quarter Scores"
};

See Also: Event

Adapter Config

BrEventListConfig

Configuration for the bet recommendation event list widget. Note: The allowedMarkets and blockedMarkets properties are only applicable when using hosted Sportradar type with UOF (Unified Odds Feed) IDs.

Property	Type	Required	Description
layout	EventListMarketsConfig	yes	Market layout configuration per sport
allowedMarkets	SportMarketsMap		Markets allowed for this widget, keyed by sport ID
blockedMarkets	SportMarketsMap		Markets blocked for this widget, keyed by sport ID

const brEventListConfig = {
  layout: {
    "1": {  // Soccer
      sportId: 1,
      markets: [
        {
          title: "1X2",
          preMatchMarketId: 1,
          liveMarketId: 1,
          columns: ["1", "X", "2"]
        },
        {
          title: "Total",
          preMatchMarketId: 18,
          liveMarketId: 18,
          showSpecifier: true,
          columns: ["Over", "Under"]
        }
      ]
    }
  },
  allowedMarkets: {
    "1": {
      "1": true,     // Allow 1X2 market with all specifiers
      "18": ["2.5"]  // Allow Total market only with 2.5 specifier
    }
  }
};

See Also: EventListMarketsConfig, SportMarketsMap

SportMarketsMap

A map of sport IDs to their market configurations with specifier filtering. Only applicable when using hosted Sportradar type with UOF (Unified Odds Feed) IDs.

Property	Type	Required	Description
[sportId]	Record<string, Specifiers>	yes	Market configurations for a sport, where keys are market IDs and values are specifier filters

Specifiers Type:

• true - Allow/block market with all specifiers

• string[] - Allow/block market only with specific specifiers (e.g., ["2.5", "3.5"] for Total markets)

const sportMarketsMap = {
  "1": {                    // Soccer (sport ID 1)
    "1": true,              // 1X2 market - all specifiers
    "18": ["2.5", "3.5"],   // Total market - only 2.5 and 3.5 lines
    "16": ["0:1", "1:0"]    // Handicap - only specific lines
  },
  "2": {                    // Basketball (sport ID 2)
    "219": true,            // Money Line
    "225": ["180.5", "200.5"]  // Total Points - specific lines
  }
};

EventListMarketsConfig

Configuration for market layout display in event lists. This is a Record<string, SportLayoutConfig> where keys are sport IDs and values are layout configurations.

Type: Record<string, SportLayoutConfig>

SportLayoutConfig

Property	Type	Required	Description
sportId	string | number	yes	Sport identifier
markets	MarketLayoutConfig[]	yes	Array of market layout configurations

MarketLayoutConfig

Property	Type	Required	Description
title	string		Display title for the market column
preMatchMarketId	string | number		Market ID to use for pre-match events
liveMarketId	string | number		Market ID to use for live events
showSpecifier	boolean		Whether to display the market specifier (e.g., "2.5" for Total)
columns	Array<string | ColumnConfig>		Column definitions for outcome display

ColumnConfig

Property	Type	Required	Description
id	string	yes	Outcome ID to display in this column
title	string		Custom column title
tKey	string		Translation key for the column title

const eventListMarketsConfig = {
  "1": {  // Soccer
    sportId: 1,
    markets: [
      {
        title: "1X2",
        preMatchMarketId: 1,
        liveMarketId: 1,
        columns: ["1", "X", "2"]
      },
      {
        title: "Total",
        preMatchMarketId: 18,
        liveMarketId: 18,
        showSpecifier: true,
        columns: [
          { id: "12", title: "Over" },
          { id: "13", title: "Under" }
        ]
      }
    ]
  },
  "2": {  // Basketball
    sportId: 2,
    markets: [
      {
        title: "Money Line",
        preMatchMarketId: 219,
        liveMarketId: 219,
        columns: ["1", "2"]
      }
    ]
  }
};

See Also: BrEventListConfig