Adapter API Reference and Types

Adapter API Reference and Types | Engagement Tools | API Hub

#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.

javascript

// Example adapter implementation
const adapter = {
  config: {
    widget: {
      'betRecommendation.eventList': {
        layout: { /* EventListMarketsConfig */ },
        allowedMarkets: { /* SportMarketsMap */ }
      }
    }
  },
  endpoints: {
    event:

warning

In all widgets below, where eventMarkets, market and availableMarketsForEvent endpoints are listed as mandatory, either eventMarkets endpoint needs to be implemented, or both market and availableMarketsForEvent, not all three.

It depends on the nature of your data, which option is more convenient to implement. If your API endpoint returns a single market object, it is more convenient to implement the market and availableMarketsForEvent combination, if your API returns a list of markets, it is more convenient to implement the eventMarkets endpoint.

#betRecommendation.highlights

#Mandatory Endpoints

eventMarkets or (market + availableMarketsForEvent)
event

#Optional Endpoints

filterMarkets - narrows markets selection for widget specific use
betSlipSelection - visual representation of markets already in betslip
cashBackSelections - adds visual representation of cash back markets

#betRecommendation.eventList

#Mandatory Endpoints

eventMarkets or (market + availableMarketsForEvent)
event

#Optional Endpoints

filterMarkets - narrows markets selection for widget specific use
betSlipSelection - visual representation of markets already in betslip
cashBackSelections - adds visual representation of cash back markets

#betRecommendation.swipeBet

#Mandatory Endpoints

eventMarkets or (market + availableMarketsForEvent)
event

#Optional Endpoints

filterMarkets - narrows markets selection for widget specific use
betSlipSelection - visual representation of markets already in betslip
cashBackSelections - adds visual representation of cash back markets

#betRecommendation.similarBets

#Mandatory Endpoints

eventMarkets or (market + availableMarketsForEvent)
event

#Optional Endpoints

filterMarkets - narrows markets selection for widget specific use
betSlipSelection - visual representation of markets already in betslip
cashBackSelections - adds visual representation of cash back markets

#betRecommendation.markets

#Mandatory Endpoints

eventMarkets or (market + availableMarketsForEvent)
event

#Optional Endpoints

betSlipSelection - visual representation of markets already in betslip

#betRecommendation.myCombo

#Mandatory Endpoints

eventMarkets or (market + availableMarketsForEvent)
event

#Optional Endpoints

betSlipSelection - visual representation of markets already in betslip

#betInsights

#Mandatory Endpoints

eventMarkets or (market + availableMarketsForEvent)
event

#Optional Endpoints

betSlipSelection - visual representation of markets already in betslip

#betConcierge

#Mandatory Endpoints

availableMarketsForEvent - the AI assistant suggests bets from one of these markets based on conversation context
eventMarkets or market - implement one (mutually exclusive); provides full market info for the AI-suggested market
betSlipSelection - marks outcomes already in the user's bet slip as selected

#Optional Endpoints

recommendedSelections - marks a selection as recommended (use for promotions)
calculateCustomBetXML - enables custom bet combo suggestions (requires enableCustomBet: true widget prop)

#virtualStadium

#Optional Endpoints

tickets - enables bet sharing
matchEventSuggestedSelection - to enable flash bet
eventMarkets or (market + availableMarketsForEvent) - to enable flash bet

note

betInsights is an optional component of Virtual Stadium. If betInsights is enabled, all adapter endpoints required by betInsights must be implemented as well.

#Complete Adapter Example

This is an example of an adapter implementing all endpoints. It is intended to be a copy/paste template, where only data fetching and transformation need to be implemented. When implementing an adapter, implement only the endpoints which are required by the widget being integrated, and discard the rest. For each endpoint, only the getData${ENDPOINT_NAME}() and transormData${ENDPOINT_NAME}() functions need to be implemented.

Expand Adapter Template Code

html

#Adapter Endpoints

#Market Function

Retrieves data for a specific market of a specific event.

warning

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 Global SIR API documentation for details on configuring odds formats.

Used by: betRecommendation.highlights, betRecommendation.eventList, betRecommendation.swipeBet, betRecommendation.similarBets, betRecommendation.markets, betRecommendation.myCombo, betInsights, betConcierge

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

javascript

// 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: "decimal"
  // }

  // Your implementation here - fetch specific market data based on args

#EventMarkets Function

Retrieves data for all markets of a specific event.

warning

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.

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

javascript

// Example implementation
adapter.endpoints.eventMarkets = (args, callback) => {
  // args example:
  // {
  //   selection: { event: "sr:match:12345", type: "uf" },
  //   language: "en",
  //   oddsType: "decimal"
  // }

  // Your implementation here - fetch markets data based on args

#Event Function

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

warning

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

javascript

// 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,

#AvailableMarketsForEvent Function

Retrieves all available market offering in Selection format for a requested event. Only called when implementing the market endpoint (not used with eventMarkets).

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

javascript

// 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

#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.

Used by: betRecommendation.highlights, betRecommendation.eventList, betRecommendation.swipeBet, betRecommendation.similarBets

The widget argument value passed by each widget:

betRecommendation.highlights and betRecommendation.similarBets → "betRecommendation"
betRecommendation.eventList → "betRecommendation.eventList"
betRecommendation.swipeBet → "betRecommendation.swipeBet"

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

javascript

// 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" }
  //   ]
  // }

#BetSlipSelection Function

Subscribes to the current bettor'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

javascript

// 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"

#CashBackSelections Function

Retrieves selections eligible for cash back promotions.

Used by: betRecommendation.highlights, betRecommendation.eventList, betRecommendation.swipeBet, betRecommendation.similarBets

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

javascript

// 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

#Tickets Function

Retrieves the bettor's placed bets (tickets).

The callback receives a TicketsResponse: prefer TicketResponseV2. Deprecated BetShareResponse remains supported for legacy Virtual Stadium integrations.

Used by: virtualStadium

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

javascript

// Example implementation (TicketResponseV2)
adapter.endpoints.tickets = (args, callback) => {
  // args example:
  // {
  //   operatorId: "operator123",
  //   endCustomerId: "customer456",
  //   events: [
  //     { event: "sr:match:12345", type: "uf" }
  //   ],
  //   channelId: "web",
  //   page: 1
  // }

  // Your implementation here - fetch user tickets based on args

#MatchEventSuggestedSelection Function

Retrieves suggested selections for a specific match event (incident).

Used by: virtualStadium

Argument	Type	Required	Description
args	`MatchEventSuggestedSelectionRequest`	yes	Request parameters including match event, event selection, and optional suggestion hint
callback	`Callback`<`MatchEventSuggestedSelectionResponse`>	yes	Function to receive suggested selections or error

Returns: UnsubscribeFunction - Optional cleanup function to stop receiving updates

javascript

// Example implementation
adapter.endpoints.matchEventSuggestedSelection = (args, callback) => {
  // args example:
  // {
  //   matchEvent: { type: "GOAL", metadata: { goal_number: "2" } },
  //   event: { event: "sr:match:12345", type: "uf" },
  //   widget: "liveMatchTracker",
  //   suggestion: {
  //     type: "Outcome",
  //     selections: [

#RecommendedSelections Function

Retrieves recommended selections for a given event.

Used by: betConcierge

Argument	Type	Required	Description
args	`RecommendedSelectionsRequest`	yes	Request parameters including event selections
callback	`Callback`<`RecommendedSelectionsResponse`>	yes	Function to receive recommended selections or error

Returns: UnsubscribeFunction - Optional cleanup function to stop receiving updates

javascript

// Example implementation
adapter.endpoints.recommendedSelections = (args, callback) => {
  // args example:
  // {
  //   events: [
  //     { event: "sr:match:12345", type: "uf" }
  //   ]
  // }

  // Your implementation here - fetch recommended selections for the given events
  // Then call callback with the result
  callback(undefined, {

#CalculateCustomBetXML Function

Calculates custom bet XML for given markets and match.

Used by: betConcierge

Argument	Type	Required	Description
args	`CalculateCustomBetXmlRequest`	yes	Request parameters containing the calculate payload
callback	`Callback`<`CalculateCustomBetXmlResponse`>	yes	Function to receive the resulting payload or error

Returns: UnsubscribeFunction - Optional cleanup function to stop receiving updates

javascript

// Example implementation
adapter.endpoints.calculateCustomBetXML = (args, callback) => {
  // args example:
  // {
  //   calculatePayload: "<filterSelections>...</filterSelections>"
  // }

  // Your implementation here - calculate custom bet XML and return result
  // Then call callback with the result
  callback(undefined, {
    payload: "<filtered_calculation_response>...</filtered_calculation_response>"

#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

javascript

// 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

#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

javascript

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")

javascript

// 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: 'decimal', 'fractional', 'moneyline', 'hong-kong', 'indonesian', 'malay'

javascript

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

// With minimal properties
const minimalRequest = {
  selection: { event: "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: 'decimal', 'fractional', 'moneyline', 'hong-kong', 'indonesian', 'malay'

javascript

// Example usage with market selection
const marketRequest = {
  selection: { event: "sr:match:12345", market: "1", type: "uf" },
  language: "en",
  oddsType: "decimal"
};

// Example with outcome selection
const outcomeRequest = {
  selection: { event: "sr:match:12345",

#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

javascript

// 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

javascript

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

#TicketsRequest

Request parameters for fetching tickets.

javascript

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

// Example with minimal properties
const minimalRequest

#MatchEventSuggestedSelectionRequest

Request parameters for fetching suggested selections for a specific match event (incident).

#`type` and `suggestedSelections`

The type field is an optional instruction indicating which selection form the client expects. When provided, the adapter is expected to return selections matching that form:

'outcome': response should contain outcome-level selections (SelectionOutcome[]).
'market': response should contain market-level selections (SelectionMarket[]).

The suggestedSelections property carries the actual suggested selections and should match the type when both are provided.

javascript

// Example usage preferring outcome-level selections
const requestWithOutcomeSuggestion = {
  matchEvent: { type: "GOAL", metadata: { goal_number: "2" } },
  event: { event: "sr:match:12345", type: "uf" },
  widget

#RecommendedSelectionsRequest

Request parameters for fetching recommended selections for given events.

Property	Type	Required	Description
events	`SelectionEvent[]`	yes	Array of event identifiers for which to retrieve recommended selections

javascript

// Example usage
const recommendedSelectionsRequest = {
  events: [
    { event: "sr:match:12345", type: "uf" },
    { event: "sr:match:67890", type: "uf" }
  ]
};

#CalculateCustomBetXmlRequest

Request parameters for calculating custom bet XML.

Property	Type	Required	Description
calculatePayload	`string`	yes	XML payload string used as input for the custom bet calculation

javascript

// Example usage
const calculateCustomBetXmlRequest = {
  calculatePayload: `<filterSelections
                        xmlns="http://schemas.sportradar.com/custombet/v1/endpoints"
                        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                        xsi:schemaLocation="http://schemas.sportradar.com/custombet/v1/endpoints
                        http://schemas.sportradar.com/custombet/v1/endpoints/Selections.xsd">
                        <selection id="sr:match:50955897">
                            <market market_id="1" outcome_id="3"/>
                        </selection>
                    </filterSelections>`
};

#Response Types

#EventResponse

Response data containing event information.

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

javascript

// 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"

#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")

javascript

// 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: {

#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")

javascript

// 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 },

#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

javascript

// Example response structure
const availableMarketsResponse = {
  selection: [
    { event: "sr:event:1", market: "1" },
    { event: "sr:event:1", market: "18", specifiers: "total=2.5" },
    { event: "sr:event:1", 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

javascript

// 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

javascript

// Example response structure
const betSlipSelectionResponse = {
  selection: [
    { event: "sr:match:12345", market: "1", outcome: "2", odds: { type: "decimal", value: "1.95" } },
      { event: "sr:match:12345", market: "18", outcome: "1",

#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

javascript

// 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

javascript

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

#TicketsResponse

Union type for the tickets endpoint callback result. Return either TicketResponseV2 (recommended) or deprecated BetShareResponse. The shapes are mutually exclusive: provide tickets or bets, never both.

Shape	Discriminator	Description
`TicketResponseV2`	`tickets` present	Current ticket format based on the v2 ticket schema
`BetShareResponse`	`bets` present	Deprecated. Legacy Virtual Stadium bet-share format

#TicketResponseV2

Current response shape for the tickets endpoint. Contains an array of v2 Ticket objects.

Property	Type	Required	Description
tickets	`Ticket`[]	yes	Array of ticket objects containing bets, selections, stake, and related data
bets	—	no	Must not be present. Reserved so this shape cannot be mixed with `BetShareResponse`

javascript

// Example response structure
const ticketResponseV2 = {
  tickets: [
    {
      ticketId: "ticket_123456",
      bets: [
        {
          betId: "bet_001",
          selections: [

#BetShareResponse (Deprecated)

Deprecated. Legacy Virtual Stadium bet-share response. New implementations should return TicketResponseV2 instead.

Property	Type	Required	Description
bets	`BetSlip`[]	yes	Array of deprecated bet-slip objects (one per shared ticket)
tickets	—	no	Must not be present. Reserved so this shape cannot be mixed with `TicketResponseV2`

javascript

// Example response structure (deprecated)
const betShareResponse = {
  bets: [
    {
      id: "ticket_123456",
      betSlipId: "654321",
      betType: "single",
      currency: "USD",
      combinedOdds: {

#MatchEventSuggestedSelectionResponse

Response data containing suggested selections for the match event.

Property	Type	Required	Description
selections	(`SelectionMarket` \| `SelectionOutcome`)[]	yes	Array of suggested market or outcome selections for the match event

javascript

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

#RecommendedSelectionsResponse

Response data containing recommended selections for the requested events.

Property	Type	Required	Description
selection	`SelectionOutcome[]`	yes	Array of recommended outcome selections

javascript

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

#CalculateCustomBetXmlResponse

Response data containing the calculated custom bet XML payload.

Property	Type	Required	Description
payload	`string`	yes	Resulting XML payload string from the custom bet calculation

javascript

// Example response structure
const calculateCustomBetXmlResponse = {
  payload: `<filtered_calculation_response generated_at="2025-04-16T13:29:08+00:00">
              <calculation odds="21.50303106727931" probability="0.030418715351118873" harmonization="false"/>
              <available_selections>
                <event id="sr:match:58265377">
                  <markets>
                    <market id="65" specifiers="hcp=0:2" conflict="false">
                      <outcome id="1711" conflict="true"/>
                      <outcome id="1712" conflict="true"/>
                      <outcome id="1713" conflict="false"/>
                    </market>

#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"`)

javascript

// 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).

#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

javascript

// 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

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).

#When `type: 'external'`

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

javascript

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

See Also: SelectionEvent, SelectionMarket, Odds

#Odds

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

javascript

// Decimal odds
const decimalOdds = {
  type: "decimal",
  value: "2.50"
};

// Fractional odds
const fractionalOdds = {
  type: "fractional",
  value: "3.2",
  numerator: "6",
  denominator: "4"
};

// Moneyline odds

#Outcome

Represents a single betting outcome within a market.

javascript

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

// Inactive outcome
const inactiveOutcome = {
  id:

See Also: Market, Odds

#Market

Represents a betting market with multiple outcomes.

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

javascript

// Active market with outcomes
const market = {
  id: "1",
  name: "Match Winner (1X2)",
  outcomes: [
    { id: "1", name: "Home", status: "active", odds: { type: "decimal", value

See Also: Outcome, Event

#Event

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

javascript

// Pre-match event
const prematchEvent = {
  id: "sr:match:12345",
  sport: { id: "1", name: "Soccer" },
  category: { id: "1", name: "England" },
  tournament: { id:

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")

javascript

// 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. In the Bet Component UI a ticket is the full card (header / body / footer). Selections live in the body; some selection types also change the header (see TicketSelection).

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
version	`string`	yes	Version of the ticket schema (for example `"2.0"`)

javascript

const ticket = {
  ticketId: "ticket_123456",
  bets: [
    {
      betId: "bet_001",
      selections: [
        {
          type: "uf",
          productId: "1",
          eventId

See Also: Bet, TicketResponseV2, TicketsResponse

#Bet

Represents one bet within a ticket, containing selections and stake information. A bet with one selection is a single; a bet with multiple selections is an accumulator. Selections may mix different TicketSelection types.

javascript

// Single bet
const singleBet = {
  betId: "bet_001",
  selections: [
    {
      type: "uf",

See Also: Ticket, TicketSelection, Stake, Payout

#Payout

Represents a cash payout amount for a bet.

Property	Type	Required	Description
type	`'cash'`	yes	Payout type. Currently only `'cash'` is supported
currency	`string`	yes	Currency code (e.g., `"USD"`, `"EUR"`, `"GBP"`)
amount	`string`	yes	Payout amount as a string to allow for decimal values

javascript

const payout = {
  type: "cash",
  currency: "USD",
  amount: "21.00"
};

See Also: Bet, PayoutWithSource

#PayoutWithSource

Extends Stake with an optional source describing where the payout originated. Used for optional cashout amounts on a Bet.

javascript

const cashout = {
  type: "cash",
  currency: "USD",
  amount: "15.50",
  source: "cashout"
};

See Also: Bet, Payout, Stake

#Stake

Represents stake information for a bet.

javascript

// 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"
};

See Also: Bet

#TicketSelection

Discriminated union type for entries in a bet's selections array. The type field discriminates between UOF, external, custom bet, system, odds-boost, ways, and payout-modifier formats.

Do not confuse Ticket with TicketSelection in the UI:

Concept	Adapter type	What the UI shows
Ticket	`Ticket`	The whole card: header (bet kind / modifiers / total odds), body (one or more selections), footer (stake / to return)
TicketSelection	this type	Data that drives a body row or group. Some types also change the ticket header (for example `odds-boost` → `BOOSTED ODD`, `payout-modifier` → `2 UP`)
Single vs accumulator	`Bet`	A single has one selection; an accumulator (multi bet) has multiple. Selection `type`s can be mixed

Example accumulator ticket (header / body / footer). Body rows are TicketSelections; stake and return belong to the ticket bet, not to a selection:

How each selection type appears on a ticket (screenshots are full tickets; note header vs body):

Examples below are complete Ticket objects (version: "2.0") as returned inside TicketResponseV2.

#When `type: 'uf'`

Use when outcomes, markets, events, and specifiers originate from UOF. Example single ticket whose body is one standard selection:

javascript

const ticketUfSingle = {
  ticketId: "ticket_uf_single",
  bets: [
    {
      betId: "bet_uf",
      selections: [
        {
          type: "uf",
          productId: "1",
          eventId

#When `type: 'external'`

Use when outcomes, events, odds, and settlements are managed by the client. Example single ticket whose body is one standard selection:

javascript

const ticketExternalSingle = {
  ticketId: "ticket_external_single",
  bets: [
    {
      betId: "bet_external",
      selections: [
        {
          type: "external",
          event: "ext:match:736977"

#When `type: 'uf-custom-bet'`

Custom bet (bet builder) composed of uf selections. Corresponds to Bet Builder in the UI. Example ticket: header shows BET BUILDER; body is the custom-bet group:

javascript

const ticketCustomBetUf = {
  ticketId: "ticket_custom_bet_uf",
  bets: [
    {
      betId

#When `type: 'custom-bet'`

Custom bet composed of external selections. Example ticket: header shows BET BUILDER; body is the custom-bet group:

javascript

const ticketCustomBetExternal = {
  ticketId: "ticket_custom_bet_external",
  bets: [
    {
      betId: "bet_custom_ext",

#When `type: 'system'`

Multiple selections that form a system bet. Example ticket: header shows system size and odds; body is the system group:

javascript

const ticketSystemUfTrixie = {
  ticketId

#When `type: 'odds-boost'`

A uf or external selection with boosted odds. Example ticket: header shows BOOSTED ODD and the boosted value; body shows the nested pick with original odds:

Property	Type	Required	Description
type	`'odds-boost'`	yes	Indicates boosted odds
selection	TicketSelectionUf \| TicketSelectionExternal	yes	Nested selection (`uf` or `external`)
odds	`Odds`	yes	Boosted odds for the selection

javascript

const ticketOddsBoost = {
  ticketId: "ticket_odds_boost",
  bets: [
    {
      betId: "bet_odds_boost",
      selections: [
        {
          type: "odds-boost",
          selection: {

#When `type: 'ways'`

One or more selections related to an event (or market) already included elsewhere in the same bet. Example ticket: header shows WAYS; body is the ways group:

Property	Type	Required	Description
type	`'ways'`	yes	Indicates ways selections
selections	TicketSelectionUf[] \| TicketSelectionExternal[] \| TicketSelectionOddsBoost[]	yes	Nested selections (`uf`, `external`, or `odds-boost`). Minimal = 2, maximum = 30

javascript

const ticketWays = {
  ticketId: "ticket_ways",
  bets: [
    {
      betId: "bet_ways",
      selections

#When `type: 'payout-modifier'`

A selection eligible for payout modification / promotion settlement (for example Supersub or Early Payout). Example ticket: header shows the promo label (for example 2 UP); body shows the nested pick:

javascript

const ticketPayoutModifier = {
  ticketId: "ticket_payout_modifier",
  bets: [
    {
      betId: "bet_payout_mod",
      selections: [
        {
          type: "payout-modifier",
          reference: "promo_2up_001"

#TicketSelectionContext

Historical display metadata for uf and external ticket selections. Extends with additional custom fields (Record<string, unknown>): you may include extra keys beyond the predefined ones below.

Why it exists: Widgets need human-readable names (event, market, outcome) to render a ticket. If context is missing, the widget may call endpoints such as event or eventMarkets to resolve those names from the selection IDs. That works for recent data, but months later the same IDs may no longer be available from those endpoints. Provide context on the ticket selection so names and related display fields can be read from the ticket itself and remain usable for historical tickets.

javascript

const context = {
  eventName: "Manchester United vs Liverpool",
  marketName: "1x2",
  outcomeName: "Home",
  tournament: "Premier League",
  sportName: "Soccer",
  categoryName: "England",
  isLive: false,
  eventStartTime: "1738519200000",
  sportId: "1"
};

#TicketSelectionCustomBetContext

Historical display metadata for uf-custom-bet and custom-bet selections. Extends with additional custom fields (Record<string, unknown>).

Property	Type	Required	Description
eventName	`string`		Event or custom-bet display name (e.g., `"Manchester United vs Liverpool"`)

javascript

const customBetContext = {
  eventName: "Manchester United vs Liverpool & Arsenal vs Chelsea"
};

#TicketSelectionSystemContext

Optional display metadata for system selections.

Property	Type	Required	Description
systemName	`string`		Human-readable system bet name (e.g., `"Trixie"`, `"Yankee"`, `"Lucky 15"`, `"Doubles"`)

javascript

const systemContext = {
  systemName: "Trixie"
};

See Also: Bet, Odds, Ticket, TicketResponseV2

#Sport

Represents information about a sport.

Property	Type	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

javascript

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)

javascript

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	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

javascript

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

javascript

const manchesterUnited = {
  id: "sr:competitor: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

javascript

// 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

See Also: Event

#BetSlip (Deprecated)

Represents a betting ticket containing one or more bets. Used only by deprecated BetShareResponse.

javascript

const betSlip = {
  id: "ticket_123456",
  betSlipId: "654321",
  betType: "single",
  currency: "USD",
  combinedOdds: {
    decimalValue: 4.33,
    displayValue: "10/3"
  },
  stake: {

#ValueObject

Property	Type	Required	Description
value	`string`	yes	Displayed representation of value

javascript

const stake = {
      value: '50.00'
  };

#BetSlipOddsObject

Property	Type	Required	Description
decimalValue	`number`	yes	Decimal representation of odds used to display change indicators
displayValue	`string`	yes	Displayed as is, representation of value

javascript

const combinedOdds: {
    decimalValue: 4.33
    displayValue: '10/3'
  };

#BetSlipBetObject

javascript

const bet = {
    id: 'bet_001',
    betType: '',
    markets: [
        {
            id: '1',
            name: subTitle,
            outcomes: [
                {
                    id: '1',
                    name: title,
                    odds

#BetSlipMarketObject

javascript

const market = {
  id: "sr:market:321",
  name: "Moneyline",
  outcomes: [
    {
      id: "sr:outcome:101",
      name: "PSG",
      odds: "1.48",
      status: { isActive: true }
    },
    {
      id:

#BetSlipOutcomeObject

javascript

const outcome = {
  id: "sr:outcome:67898",
  name: "Denver Nuggets",
  oddsDecimal: 2.55,
  status: { isActive: true }
};

#BetSlipEventObject

javascript

const event = {
  id: "sr:event:98765",
  externalId: "123456",
  name: "Heat VS Nuggets",
  teams: [
    { id: "sr:competitor:113", name: "Miami Heat" },
    { id: "sr:competitor:118", name: "Denver Nuggets" }
  ]
};

See Also: BetShareResponse, TicketsResponse

#MatchEvent

Represents a match event (incident) that occurred during a sporting event, such as a goal, red card, or substitution.

Property	Type	Required	Description
type	`string`	yes	UPPER_CASE event type identifier (see Type Values below)
metadata	`object \| null`		Additional data whose shape depends on `type` (see Metadata by Type below)
tag	`string`		Deprecated. Channel identifier from which this match event originated. Prefer using `channelId`/`channelOriginId` passed separately in the request

#Type Values

Soccer

Basketball

Value	Description
`ONE_POINT_SCORED`	A free throw (1-point score) was made
`TWO_POINT_SCORED`	A 2-point basket was scored
`THREE_POINT_SCORED`	A 3-point basket was scored
`TIMEOUT`	A timeout was called
`PLAYER_EJECTED`	A player was ejected (disqualified)
`QUARTER_STARTED`	A new quarter began

Tennis

Value	Description
`GAME_WON`	A game was won
`BREAK_WON`	A break of serve was won
`SET_WON`	A set was won
`SET_STARTED`	A new set began (set 2 onward)
`FIRST_SET_STARTED`	The first set began

Cross-sport

Value	Description
`MATCH_STARTED`	The match began
`MATCH_ENDED`	The match ended
`TOURNAMENT_MATCH_START_IN_ONE_DAY`	Scheduled match starts in 1 day
`TOURNAMENT_MATCH_START_IN_ONE_HOUR`	Scheduled match starts in 1 hour
`TOURNAMENT_MATCH_START_IN_FIVE_MINUTES`	Scheduled match starts in 5 minutes

#Metadata by Type

javascript

// Soccer: 2nd goal scored
const goalEvent = {
  type: "GOAL",
  metadata: { goal_number: "2" }
};

// Soccer: penalty kick awarded to the home team
const penaltyEvent = {
  type: "PENALTY_KICK",
  metadata: { team: "home" }
};

#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

javascript

const brEventListConfig = {
  layout: {
    "1": {  // Soccer
      sportId: 1,
      markets: [
        {
          title: "1X2",
          preMatchMarketId: 1,
          liveMarketId: 1,

#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

Value	Meaning
`true`	Allow/block this market id regardless of specifiers
`false` / `null` / `undefined` / `''`	Allow/block only when the market has no specifiers
`SpecifierRule[]`	Allow/block when any rule matches (OR). Rules are for markets with specifiers only

SpecifierRule (array entry):

Form	Example	Meaning
Legacy pipe string	`"total=2.5\|variant=sr:exact"`	Exact key/value set (order of keys ignored)
Structured object	`{ total: true, variant: "sr:exact" }`	Exact key set; each key constrained (see below)

Per-key constraint in a structured rule:

Constraint	Meaning
`true`	Any value for that key
`string`	Exact value
`string[]`	Value must be one of the listed values

Structured rules require the market to have exactly those specifier keys (no missing keys, no extra keys).

javascript

const sportMarketsMap = {
  "1": {                                      // Soccer (sport ID 1)
    "1": true,                                // 1X2 - any / no specifiers
    "10": false,                              // Double Chance - no specifiers only
    "18": ["total=2.5", "total=3.5"],         // Total - exact legacy strings
    "16": [{ hcp:

#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

#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

javascript

const eventListMarketsConfig = {
  "1": {  // Soccer
    sportId: 1,
    markets: [
      {
        title: "1X2",
        preMatchMarketId: 1,
        liveMarketId: 1,
        columns: ["1", "X", "2"

See Also: BrEventListConfig

Property	Type	Description
availableMarketsForEvent	AvailableMarketsForEvent	Retrieves all available markets selections for a specific event. Use with `market` endpoint to discover available markets.
market	Market	Implement either this OR `eventMarkets` – Retrieves a specific market data for a specific event.
eventMarkets	EventMarkets	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	Event	Retrieves detailed event data including event start time, scores, team names, tournament name, and more.
filterMarkets	FilterMarkets	Filters available markets based on widget requirements and provided selections, returning all or a subset.
betSlipSelection	BetSlipSelection	Subscribes to the current bettor's bet slip selections (their betting cart)
cashBackSelections	CashBackSelections	Retrieves selections eligible for cash back promotions.
tickets	Tickets	Retrieves the bettor's placed bets (tickets)
matchEventSuggestedSelection	MatchEventSuggestedSelection	Retrieves suggested selections for a specific match event (incident).
recommendedSelections	RecommendedSelections	Retrieves recommended selections for a given event.
calculateCustomBetXML	CalculateCustomBetXML	Calculates custom bet XML for given markets and match.

<script type="text/javascript">
// Widget loader script from Step 3 
ndatory 
// -------- Data + Transform functions --------

async function getDataMarket(args) {
  // Here fetch data from your data source and return it
  return {};
}

function transformDataMarket(data) {
  // Here transform your data into data structure exemplified by the object below.
  /*
  // Illustration how data transformation might work from client data to Adapter types
  return {
    market: {
      id: data.marketId,
      name: data.marketName,
      outcomes: data.outcomes.map((outcome) =>  { id: outcome.id, name: outcome.name, odds: outcome.odds } )
    },
    event: { id: data.eventId, type: data.eventType }
  };
  */

  return {
    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: "sr:match:12345"
  };
}

async function getDataAvailableMarketsForEvent(args) {
  // Here fetch data from your data source and return it
  return {};
}

function transformDataAvailableMarketsForEvent(data) {
  // Here transform your data into data structure exemplified by the object below.
  /*
  // Illustration how data transformation might work from client data to Adapter types
  return {
    selection: data.map((selection) => { type: selection.type, event: selection.event, market: selection.market})
  }; 
  */

  return {
    selection: [
      {
        type: "uf",
        event: "61513908",
        market: "1",
      },
    ],
  };
}

async function getDataEventMarkets(args) {
  // Here fetch data from your data source and return it
  return {};
}

function transformDataEventMarkets(data, args) {
  // Here transform your data into data structure exemplified by the object below.
  /*
  // Illustration how data transformation might work from client data to Adapter types
  let markets = []

  function mapMarkets(market){
    return {
      id: market.id,
      status: market.status,
      name: market.name,
      outcomes: market.outcomes.map((outcome) => {id: outcome.id, name: outcome.name , odds: { type: outcome.odds.type, value: outcome.odds.value}, status: outcome.status})
    };
  }

  return data.forEach(mapMarkets);
  */

  return {
    event: args.selection.event,
    markets: [
      {
        id: "1",
        status: "active",
        name: "1x2",
        outcomes: [
          {
            id: "1",
            name: "Tenhaisen",
            odds: { type: "decimal", value: "1.88" },
            status: "active",
          },
          {
            id: "2",
            name: "draw",
            odds: { type: "decimal", value: "3.85" },
            status: "active",
          },
          {
            id: "3",
            name: "Hoftenstain",
            odds: { type: "decimal", value: "3.7" },
            status: "active",
          },
        ],
      },
    ],
  };
}

async function getDataEvent(args) {
  // Here fetch data from your data source and return it
  return {};
}

function transformDataEvent(data) {
  // Here transform your data into data structure exemplified by the object below.
  /*
  // Illustration how data transformation might work from client data to Adapter types
  return {
    event: {
      id: data.event,
      date: {
        displayValue: data.displayTime,
        startTime: data.dateTime,
      },
      sport: {
        id: data.sport.id,
        name: data.sport.name,
      },
      category: {
        id: data.category.id,
        name: data.category.country,
      },
      tournament: {
        id: data.tournament.id,
        name: data.tournament.name,
      },
      teams: data.teams.map((team) => {id: team.id, name: team.name}),
      isLive: data.isLive,
    },
  }; 
  
  */
  return {
    event: {
      id: args.selection.event,
      date: {
        displayValue: "14/01/26, 19:30",
        startTime: "2026-01-14T19:30:00.000Z",
      },
      sport: {
        id: "1",
        name: "Soccer",
      },
      category: {
        id: "30",
        name: "Germany",
      },
      tournament: {
        id: "42",
        name: "Liga Supreme",
      },
      teams: [
        { id: "1270229", name: "Tenhaisen" },
        { id: "31531", name: "Hoftenstain" },
      ],
      isLive: false,
    },
  };
}

async function getDataFilterMarkets(args) {
  // Here fetch data from your data source and return it
  return {};
}

function transformDataFilterMarkets(data) {
  // Here transform your data into data structure exemplified by the object below.
  /*
  // Illustration how data transformation might work from client data to Adapter types
  return {
    selection: data.selection.map((market) => {type: market.type, event: market.event, market: market.id})
  }
  */
  return {
    selection: [
      {
        type: "uf",
        event: "61513908",
        market: "1",
      },
    ],
  };
}

async function getDataBetSlipSelection(args) {
  // Here fetch data from your data source and return it
  return {};
}

function transformDataBetSlipSelection(data) {
  // Here transform your data into data structure exemplified by the object below.
  /*
  // Illustration how data transformation might work from client data to Adapter types
  return {
    selection: data.selection.map((market) => {event: market.event, market: market.market, outcome: market.outcome, type: market.type}),
  };
  */

  return {
    selection: [
      {
        event: "61513908",
        market: "1",
        outcome: "1",
        type: "uf",
      },
    ],
  };
}

async function getDataCashBackSelections(args) {
  // Here fetch data from your data source and return it
  return {};
}

function transformDataCashBackSelections(data) {
  // Here transform your data into data structure exemplified by the object below.
  /*
  // Illustration how data transformation might work from client data to Adapter types
  return {
    events: data.events.map((event) => {event: event.id, type: event.type}),
  }
  */

  return {
    events: [
      {
        event: "56418457",
        type: "uf",
      },
    ],
  };
}

async function getDataTickets(args) {
  // Here fetch data from your data source and return it
  return {};
}

function transformDataTickets(data) {
  // Here transform your data into data structure exemplified by the object below.
  /*
  // Illustration how data transformation might work from client data to Adapter types
  return {
    tickets: data.tickets.map((ticket) => {
      ticketId: ticket.id,
      bets: ticket.bets.map((bet) => {
        betId: bet.id,
        selections: bet.selections.map((selection) => {
          type: selection.type,
          eventId: selection.eventId,
          marketId: selection.marketId,
          outcomeId: selection.outcomeId,
          odds: { type: selection.odds.type, value: selection.odds.value },
        }),
        odds: { type: bet.odds.type, value: bet.odds.value },
        stake: bet.stake.map((stake) => {
          type: stake.type,
          currency: stake.currency,
          amount: stake.amount,
          mode: stake.mode
        }),
      }),
      version: ticket.version,
    }),
  };
  */

  return {
    tickets: [
      {
        ticketId: "ticket_123456",
        bets: [
          {
            betId: "bet_001",
            selections: [
              {
          type: "uf",
          productId: "1",
          eventId: "sr:match:12345",
          marketId: "1",
          outcomeId: "1",
          odds: { type: "decimal", value: "2.10" },
          context: {
            eventName: "Manchester United vs Liverpool",
            marketName: "1x2",
            outcomeName: "Home",
            tournament: "Premier League",
            sportName: "Soccer",
            categoryName: "England",
            isLive: false,
            eventStartTime: "1738519200000",
            sportId: "1"
          }
        }
            ],
            odds: { type: "decimal", value: "2.10" },
            stake: [{
              type: "cash",
              currency: "USD",
              amount: "10.00",
              mode: "total"
            }],
            payout: [{ type: "cash", currency: "USD", amount: "21.00" }]
          }
        ],
        version: "2.0"
      }
    ]
  };
}

async function getDataMatchEventSuggestedSelection(args) {
  // Here fetch data from your data source and return it
  return {};
}

function transformDataMatchEventSuggestedSelection(data) {
  // Here transform your data into data structure exemplified by the object below.
  /*
  // Illustration how data transformation might work from client data to Adapter types
  return {
    selections: data.selections.map((selection) => {
      event: selection.event,
      market: selection.market,
      outcome: selection.outcome,
      type: selection.type,
      specifiers: selection.specifiers
    })
  };
  */

  return {
    selections: [
      { event: "sr:match:12345", market: "1", outcome: "1", type: "uf" },
      { event: "sr:match:12345", market: "18", specifiers: "total=2.5", type: "uf" }
    ]
  };
}

async function getDataRecommendedSelections(args) {
  // Here fetch data from your data source and return it
  return {};
}

function transformDataRecommendedSelections(data) {
  // Here transform your data into data structure exemplified by the object below.
  /*
  // Illustration how data transformation might work from client data to Adapter types
  return {
    selection: data.selections.map((selection) => {
      event: selection.event,
      market: selection.market,
      outcome: selection.outcome,
      type: selection.type,
      specifiers: selection.specifiers
    })
  };
  */

  return {
    selection: [
      { event: "sr:match:12345", market: "1", outcome: "1", type: "uf" },
      { event: "sr:match:67890", market: "18", specifiers: "total=2.5", outcome: "13", type: "uf" }
    ]
  };
}

async function getDataCalculateCustomBetXML(args) {
  // Here fetch data from your data source and return it
  return {};
}

function transformDataCalculateCustomBetXML(data) {
  // Here transform your data into data structure exemplified by the object below.
  /*
  // Illustration how data transformation might work from client data to Adapter types
  return {
    payload: '<xml>data</xml>',
  }
  */
  return {
    payload: `<filtered_calculation_response generated_at="2025-04-16T13:29:08+00:00">
                <calculation odds="27.50303106727931" probability="0.027418715351118873" harmonization="false"/>
                <available_selections>
                  <event id="sr:match:12345678">
                    <markets>
                      <market id="65" specifiers="hcp=0:2" conflict="false">
                        <outcome id="1711" conflict="true"/>
                        <outcome id="1712" conflict="true"/>
                        <outcome id="1713" conflict="false"/>
                      </market>
                      ...
                    </markets>
                  </event>
                </available_selections>
              </filtered_calculation_response>`
  };
}

// -------- Adapter --------

const adapter = {
  config: {},
  endpoints: {
    market: (args, callback) => {
      getDataMarket(args)
        .then(data => transformDataMarket(data))
        .then(result => callback(undefined, result));
      return () => {};
    },

    availableMarketsForEvent: (args, callback) => {
      getDataAvailableMarketsForEvent(args)
        .then(data => transformDataAvailableMarketsForEvent(data))
        .then(result => callback(undefined, result));
      return () => {};
    },

    eventMarkets: (args, callback) => {
      getDataEventMarkets(args)
        .then(data => transformDataEventMarkets(data, args))
        .then(result => callback(undefined, result));
      return () => {};
    },

    event: (args, callback) => {
      getDataEvent(args)
        .then(data => transformDataEvent(data, args))
        .then(result => callback(undefined, result));
      return () => {};
    },

    filterMarkets: (args, callback) => {
      getDataFilterMarkets(args)
        .then(data => transformDataFilterMarkets(data))
        .then(result => callback(undefined, result));
      return () => {};
    },

    betSlipSelection: (args, callback) => {
      getDataBetSlipSelection(args)
        .then(data => transformDataBetSlipSelection(data))
        .then(result => callback(undefined, result));
      return () => {};
    },

    cashBackSelections: (args, callback) => {
      getDataCashBackSelections(args)
        .then(data => transformDataCashBackSelections(data))
        .then(result => callback(undefined, result));
      return () => {};
    },

    tickets: (args, callback) => {
      getDataTickets(args)
        .then(data => transformDataTickets(data))
        .then(result => callback(undefined, result));
      return () => {};
    },

    matchEventSuggestedSelection: (args, callback) => {
      getDataMatchEventSuggestedSelection(args)
        .then(data => transformDataMatchEventSuggestedSelection(data))
        .then(result => callback(undefined, result));
      return () => {};
    },

    recommendedSelections: (args, callback) => {
      getDataRecommendedSelections(args)
        .then(data => transformDataRecommendedSelections(data))
        .then(result => callback(undefined, result));
      return () => {};
    },

    calculateCustomBetXML: (args, callback) => {
      getDataCalculateCustomBetXML(args)
        .then(data => transformDataCalculateCustomBetXML(data))
        .then(result => callback(undefined, result));
      return () => {};
    },
  },
};
</script>

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

Property	Type	Required	Description
matchEvent	`MatchEvent`	yes	Match event (incident) information
event	`SelectionEvent`	yes	Event identifier in UF or external format
widget	`string`	yes	Widget making this request
type	`'outcome'` \| `'market'`		Optional instruction indicating the selection form the client expects. When provided, the adapter is expected to return selections of the requested form (see details below).
suggestedSelections	`SelectionOutcome[]` \| `SelectionMarket[]`		Optional suggested selections for the match event. Use outcome array when `type` is `'outcome'`, market array when `type` is `'market'`.
channelId	`string`		Current viewing channel identifier
channelOriginId	`string`		Channel from which the match event originated (e.g., when the widget is opened on a tournament channel that received the event from a child channel)

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"`)

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

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)

Property	Type	Required	Description
type	`string`	yes	Odds format. Valid values: `'decimal'`, `'fractional'`, `'moneyline'`, `'hong-kong'`, `'indonesian'`, `'malay'`
value	`string`	yes	Odds value submitted by the client. Pattern: optional leading `+` or `-` (moneyline odds), then 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 `'fractional'`. Regex: `^[1-9]\d{0,7}$`
denominator	`string`		Denominator of fractional odds. Only present when `type` is `'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

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'

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

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)

Property	Type	Required	Description
betId	`string`	yes	Unique bet id (in the client's system), minimal string length = 1, maximum length = 128
selections	`TicketSelection[]`	yes	Array of bet selections included in this bet, minimal number of selections per bet = 1, maximum number = 100
stake	`Stake[]`	yes	Array of bet stakes, minimal number of stake per bet = 1, maximum number = 5
odds	`Odds`	yes	The odds for this bet
payout	`Payout[]`		Optional potential payout for this bet. If omitted, it may be calculated and rounded based on internal logic
cashout	`PayoutWithSource[]`		Optional cashout amounts for display or use cases where cashout is available

Property	Type	Required	Description
type	`'cash' \| 'bonus'`	yes	Stake/payout type
currency	`string`	yes	Currency code (e.g., `"USD"`, `"EUR"`, `"GBP"`)
amount	`string`	yes	Amount as a string to allow for decimal values
mode	`'unit' \| 'total'`		Stake mode. Defaults to `'total'`
source	`'cash' \| 'bonus' \| 'odds-boost' \| 'cancel' \| 'cashout' \| 'ext-settlement' \| 'manual-cancel' \| 'manual-cashout'`		Optional origin of the payout amount

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)

Adapter `type`	Ticket UI role	Example ticket
`uf` or `external`	Standard pick in the body. Ticket header is usually `SINGLE` / `MULTI BET`
`uf-custom-bet` or `custom-bet`	Bet-builder body group; header often shows `BET BUILDER` and combined odds
`system`	System body group; header shows size and odds (for example `2/4`)
`odds-boost`	Header shows `BOOSTED ODD` and boosted odds; body still shows the nested `uf` / `external` pick with original odds
`ways`	Ways body group; header shows `WAYS` and odds
`payout-modifier`	Header shows the promo label (for example `2 UP`); body shows the nested pick

Property	Type	Required	Description
type	`'uf'`	yes	Indicates Unified Feed format
eventId	`string`	yes	Betting event as defined by UOF. Minimal length = 1, maximum = 100
marketId	`string`	yes	Betting market as defined by UOF. Minimal length = 1, maximum = 100
outcomeId	`string`	yes	Market outcome as defined by UOF. Minimal length = 1, maximum = 1000
odds	`Odds`	yes	Odds for the selection
productId	`string`		UOF producer id (e.g., `"1"` for LiveOdds, `"5"` for Premium Cricket). Minimal length = 1, maximum = 5
specifiers	`string`		Additional market data as defined by UOF (e.g., `"total=2.5"`). Minimal length = 1, maximum = 1000
context	`TicketSelectionContext`		Optional historical display context for this selection. Prefer providing it so tickets remain readable after market/event data ages out

Property	Type	Required	Description
type	`'external'`	yes	Indicates external client-defined format
event	`string`	yes	Unique event identifier as defined by the client. Minimal length = 1, maximum = 100
outcome	`string`	yes	Unique outcome identifier as defined by the client (should uniquely designate market and selection). Minimal length = 1, maximum = 1000
odds	`Odds`	yes	Odds for the selection
expSettleTime	`string`		Expected settlement time (Unix time milliseconds). Widgets may use this to filter, update status, or prevent copying
context	`TicketSelectionContext`		Optional historical display context for this selection. Prefer providing it so tickets remain readable after market/event data ages out

Property	Type	Required	Description
type	`'uf-custom-bet'`	yes	Indicates a UOF custom bet
selections	TicketSelectionUf[]	yes	Nested selections; only `type: 'uf'` is allowed
odds	`Odds`	yes	Odds for the custom bet
useHarmOdds	`boolean`		When true, instruct the UOF CB API to use harmonized odds. Default is `false`
context	`TicketSelectionCustomBetContext`		Optional historical display context for the custom bet as a whole

Property	Type	Required	Description
type	`'custom-bet'`	yes	Indicates an external custom bet
selections	TicketSelectionExternal[]	yes	Nested selections; only `type: 'external'` is allowed
odds	`Odds`	yes	Odds for the custom bet
context	`TicketSelectionCustomBetContext`		Optional historical display context for the custom bet as a whole

Property	Type	Required	Description
type	`'system'`	yes	Indicates a system bet
selections	TicketSelectionUf[] \| TicketSelectionExternal[]	yes	Nested selections; all must be the same type (`uf` or `external`)
size	`number[]`	yes	Unique system sizes (e.g., `[2, 3]` for 2/4 and 3/4). Minimal items = 1, maximum = 30
context	`TicketSelectionSystemContext`		Optional system-bet display context

Property	Type	Required	Description
type	`'payout-modifier'`	yes	Indicates a payout modifier
reference	`string`	yes	Unique promotion identifier used in settlement messages
description	`string`	yes	Promotion type description (e.g., `"Early Payout"`, `"2 Up"`, `"Supersub"`). Minimal length = 1, maximum = 512
selections	TicketSelectionUf \| TicketSelectionExternal	yes	Nested selection (`uf` or `external`)

Property	Type	Description
eventName	`string`	Event display name (e.g., `"Manchester United vs Liverpool"`)
marketName	`string`	Market display name (e.g., `"1x2"`, `"Total Points (incl. OT)"`)
outcomeName	`string`	Outcome display name (e.g., `"Home"`, `"Over 210.5"`)
tournament	`string`	Tournament name (e.g., `"Premier League"`, `"NBA"`)
sportName	`string`	Sport name (e.g., `"Soccer"`, `"Basketball"`)
sportId	`string`	Sport identifier (e.g., `"1"`)
categoryName	`string`	Geographic or organizational grouping (e.g., `"England"`, `"USA"`)
isLive	`boolean`	Whether the event is currently live. Helps widgets show a Live badge or prioritize the selection
eventStartTime	`string`	Expected event start time in Unix milliseconds. Widgets may use this to filter, update status, or prevent copying

Property	Type	Required	Description
id	`string`	yes	Client defined string to identify the ticket (unique in the client's system)
betSlipId	`string`		Client defined string to identify the bet slip (unique in the client's system)
betType	`'single' \| 'multibet' \| 'sameGameMulti'`	yes	Valid values: `'single'`, `'multibet'`, `'sameGameMulti'`
currency	`string`	yes	Currency as displayed
stake	`BetSlipOddsObject`		Stake for ticket
stake	`ValueObject`		Stake for ticket
payout	`ValueObject`		Payout for ticket
bets	`BetSlipBetObject`	yes	Bets for ticket

Property	Type	Required	Description
id	`string`	yes	Client defined string to identify the bet (unique in the client's system)
betType	`'betBuilder' \| ''`		`'betBuilder'` for a bet builder bet; empty string for a regular bet
event	`BetSlipEventObject`	yes	Client defined string to identify the bet (unique in the client's system)
markets	`BetSlipMarketObject`	yes	Client defined string to identify the bet (unique in the client's system)
odds	`BetSlipOddsObject`		Odds for bet

Property	Type	Required	Description
id	`string \| number`	yes	The unique identifier of the market
name	`string`	yes	The name of the market
outcomes	`BetSlipOutcomeObject[]`	yes	Array of outcomes for this market
status	`object`		Market status
status.isActive	`boolean`		Deprecated. Whether the market is active
status.status	`'active' \| 'deactivated' \| 'suspended' \| 'settled' \| 'cancelled'`		Market status string (preferred over `status.isActive`)
specifier	`object`		Market specifier information
specifier.value	`string \| number`		Specifier value (e.g., `"2.5"` for a Total market)
odds	`object`		Combined odds for the market
odds.decimalValue	`number`		Numeric decimal representation of odds, used for displaying change indicators
odds.displayValue	`string`		String representation of odds, displayed as-is with no formatting

Property	Type	Required	Description
id	`string \| number`	yes	The unique identifier assigned to the market outcome
name	`string`	yes	The name of the market outcome
odds	`number \| string`		Odds value displayed as-is — no formatting is applied
oddsDecimal	`number`		Numeric decimal representation of odds, used for displaying change indicators
competitor	`string`		Name or identifier of the competitor associated with this outcome
status	`object`		Outcome status
status.isActive	`boolean`		Whether the outcome is available for betting

Property	Type	Required	Description
id	`string`	yes	The unique identifier assigned to the event
externalId	`string \| number`		Your unique identifier for the event
name	`string`		Match name. If not provided, it is aggregated from teams as `"{teams[0].name} vs {teams[1].name}"`. If teams are also absent, the match name will be empty
teams	`Array<{ id?: string; name: string }>`		Array of exactly two teams (home and away)
date	`string`		Event date
sport	`Sport`		Sport information
category	`Category`		Category information (e.g., country, region)
tournament	`Tournament`		Tournament information
isLive	`boolean`		Whether the event is currently live
liveCurrentTime	`string \| number`		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)

Value	Description
`GOAL`	A goal was scored
`YELLOW_CARD`	A yellow card was issued
`RED_CARD`	A red card (or second yellow / direct red) was issued
`CORNER`	A corner kick was awarded
`PENALTY_KICK`	A penalty kick was awarded
`PENALTY_SHOOTOUT`	A penalty shoot-out event occurred
`OFFSIDE`	An offside was called
`SECOND_HALF_STARTED`	The second half began
`OVERTIME_STARTED`	Overtime began
`PENALTY_SHOOTOUT_STARTED`	The penalty shoot-out phase began

`type`	`metadata` shape	Notes
`GOAL`	`{ goal_number: string }`	Total goals scored (home + away) at the time of the event
`PENALTY_KICK`	`{ team: "home" \| "away" }` or `null`	`null` when the team cannot be identified from the feed
`TIMEOUT`	`{ quarter_number: string }`	Period number as a string; `"OT"` when in overtime (period > 4)
`QUARTER_STARTED`	`{ quarter_number: string }`	Period number as a string; `"OT"` when in overtime (period > 4)
`GAME_WON`	`{ set_number: string }`	Current set number
`BREAK_WON`	`{ set_number: string }`	Current set number
`SET_STARTED`	`{ set_number: string }`	Current set number
(all others)	`null`	—

Property	Type	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

Adapter API Reference and Types

#Adapter Object

Expanded Table

#Config Object

Expanded Table

#WidgetConfig

Expanded Table

#Endpoints Object

Expanded Table

#Widget Specific Endpoints

#betRecommendation.highlights

#Mandatory Endpoints

#Optional Endpoints

#betRecommendation.eventList

#Mandatory Endpoints

#Optional Endpoints

#betRecommendation.swipeBet

#Mandatory Endpoints

#Optional Endpoints

#betRecommendation.similarBets

#Mandatory Endpoints

#Optional Endpoints

#betRecommendation.markets

#Mandatory Endpoints

#Optional Endpoints

#betRecommendation.myCombo

#Mandatory Endpoints

#Optional Endpoints

#betInsights

#Mandatory Endpoints

#Optional Endpoints

#betConcierge

#Mandatory Endpoints

#Optional Endpoints

#virtualStadium

#Optional Endpoints

#Complete Adapter Example

#Adapter Endpoints

#Market Function

Expanded Table

#EventMarkets Function

Expanded Table

#Event Function

Expanded Table

#AvailableMarketsForEvent Function

Expanded Table

#FilterMarkets Function

Expanded Table

#BetSlipSelection Function

Expanded Table

#CashBackSelections Function

Expanded Table

#Tickets Function

Expanded Table

#MatchEventSuggestedSelection Function

Expanded Table

#RecommendedSelections Function

Expanded Table

#CalculateCustomBetXML Function

Expanded Table

#Utility Types

#Callback<T>

Expanded Table

#UnsubscribeFunction

#Request Types

#EventRequest

Expanded Table

#EventMarketsRequest

Expanded Table

#MarketRequest

Expanded Table

#AvailableMarketsForEventRequest

Expanded Table

#FilterMarketsRequest

Expanded Table

#TicketsRequest

Expanded Table

#MatchEventSuggestedSelectionRequest

Expanded Table

#`type` and `suggestedSelections`

#When `type: 'uf'`

#When `type: 'external'`

#When `type: 'uf'`

#When `type: 'external'`

#When `type: 'uf'`

#When `type: 'external'`