Implementing the Tickets Adapter Endpoint

#Intended Audience

• Developers implementing a custom adapter for Virtual Stadium or Central Hub
• Integrators managing adapter communication between widgets and backend systems

#Goals

By completing this tutorial, you will:

• Understand the two implementation methods for the tickets adapter endpoint
• Implement a tickets request handler that returns TicketResponseV2 via callback
• Choose between delivering all tickets immediately (Option A) or paginating with ticketsFetchMore (Option B)
• Handle the ticketsFetchMore onAction when using pagination

#Prerequisites

Before implementing the tickets endpoint, ensure you have:

• A backend API or database that stores user bet / ticket data
• Familiarity with callback-based request handlers
• Access to the Adapter Types documentation for endpoint specifications
• Bet sharing enabled in your integration (Virtual Stadium chat or Central Hub)

#Verified against

This tutorial reflects behaviour verified in the widgets repo (MR 15860):

#Overview

The tickets endpoint retrieves a user's placed bets and returns them as v2 Ticket objects inside a TicketResponseV2. This powers bet-sharing UIs — for example the Virtual Stadium chat bet-share picker and Central Hub share-betslip screens.

There are two implementation methods. Both use the same tickets(args, callback) signature and may return an unsubscribe function for cleanup when the picker closes, but they differ in how data is delivered:

See the Tickets Function reference for flow diagrams and field details.

#Track A — Non-paginated (recommended for getting started)

Return the user's full open-ticket list in a single callback. The widget renders everything immediately with no pagination.

#Step 1: Register your adapter

Register your adapter with the SIR global function before adding any widgets. Ensure only one adapter is registered per page load.

const adapter = {
  endpoints: {
    // tickets endpoint added in the next steps
  }
};

SIR('registerAdapter', adapter);

#Step 2: Implement the tickets endpoint skeleton

Add the tickets handler. Store nothing yet — just wire the callback pattern.

adapter.endpoints.tickets = (args, callback) => {
  // args.endCustomerId — the logged-in user's ID
  // args.events — optional filter by match events on the current channel
  // args.channelId — optional Virtual Stadium channel ID

  return () => {
    // Cleanup: cancel any in-flight fetch when the picker closes
  };
};

#Step 3: Fetch all tickets from your backend

Retrieve the user's complete open-ticket list. Apply optional events filtering if provided.

adapter.endpoints.tickets = (args, callback) => {
  fetchAllUserTickets(args.endCustomerId, args.events, (error, allTickets) => {
    if (error) {
      return callback(error);
    }
    // Continue to Step 4
  });

  return ()

#Step 4: Map to Ticket[] and call callback once

Transform your backend data into v2 Ticket objects and emit the full list.

adapter.endpoints.tickets = (args, callback) => {
  fetchAllUserTickets(args.endCustomerId, args.events, (error, allTickets) => {
    if (error) {
      return callback(error);
    }

    const tickets = allTickets.map

Each ticket must include ticketId, version: "2.0", and at least one Bet with selections, odds, and stake. Provide TicketSelectionContext on each selection so tickets remain readable after market data ages out.

#Step 5: Verify in the widget

Open the bet-share picker (Virtual Stadium chat or Central Hub). All tickets should appear immediately without pagination.

#Complete example — Track A

function mapBackendTicketToV2Ticket(backendTicket) {
  return {
    ticketId: backendTicket.id,
    version: "2.0",
    bets: backendTicket

#Track B — Paginated (large ticket histories)

Return the first batch with pageSize, hasMore, and nextCursor. When the widget needs the next page, it fires onAction ticketsFetchMore; you load the next batch and call the stored callback with { newTickets, ... }.

#Step 1: Implement the tickets endpoint skeleton

Same as Track A Step 1–2, but store the callback reference so the embed page can push subsequent pages.

let ticketsCallback = null;
let currentCustomerId = null;

const adapter = {
  endpoints: {
    tickets: (args, callback) => {
      ticketsCallback = callback;
      currentCustomerId = args.endCustomerId;
      // Continue in Step 2
      return () => {

#Step 2: Return the first page with pagination metadata

Signal paginated mode by including pageSize and hasMore on the first callback.

tickets: (args, callback) => {
  ticketsCallback = callback;
  currentCustomerId = args.endCustomerId;

  fetchTicketPage(args.endCustomerId, null, args.events, (error, page) => {
    if (error) {

#Step 3: Expose a loadMoreTickets function on the embed page

Create a function the onAction handler can call. It fetches the next page and pushes newTickets on the stored callback.

function loadMoreTickets(cursor) {
  if (!ticketsCallback || !currentCustomerId) {
    return;
  }
  fetchTicketPage(currentCustomerId, cursor, null, (error, page) => {
    if (error) {
      return ticketsCallback(error);
    }
    ticketsCallback

#Step 4: Handle onAction ticketsFetchMore

Wire the widget's ticketsFetchMore onAction to your loadMoreTickets function.

SIR('addWidget', '#sr-vs-widget', 'virtualStadium', {
  onAction: function(action) {
    if (action.type === 'ticketsFetchMore') {
      loadMoreTickets(action.data?.cursor);
    }
  }
});

#Step 5: Set hasMore false on the final page

On the last batch, return hasMore: false (and omit nextCursor). The widget stops requesting more pages.

ticketsCallback(undefined, {
  newTickets: lastPageItems.map(mapBackendTicketToV2Ticket),
  hasMore: false
});

#Step 6: Verify pagination in the widget

Open the bet-share picker. Confirm:

1. The first page renders immediately.
2. When the widget requests the next page (ticketsFetchMore), the next batch loads and appends.
3. Loading stops when hasMore: false is returned.

#Complete example — Track B

<script>
  let ticketsCallback =

#Response fields (both tracks)

Deliver data on the same callback from the initial tickets() call — never invoke tickets() again for page 2+.

#Legacy format

#Next Steps

• Review the Tickets Function reference for flow diagrams and field tables
• See Ticket and TicketSelection for the full v2 schema and UI mapping
• Configure Virtual Stadium bet share: Hosted adapter or Custom adapter
• For frontend copy-bet behaviour, see the Copy Bet Button guide