How to Integrate Retool with Eventbrite

Eventbrite provides private API tokens for accessing data from your own organizer account without requiring end users to authorize via OAuth. To generate a token, log into your Eventbrite account at eventbrite.com. Navigate to Account Settings (click your avatar in the top-right corner, then Account Settings). In the left sidebar, scroll down to find 'Developer Links' or navigate directly to eventbrite.com/platform/api-keys. On the API keys page, you will see your existing applications and the option to create new ones. Click 'Create API Key' or find an existing key. Each API key has a 'Private Token' — this is what you use as a Bearer token in Retool for accessing your own organizer data. Copy the private token value and store it securely. Private tokens provide full access to your Eventbrite organizer account — treat them like a password. For accessing data across multiple organizer accounts (for event agencies managing many clients), you would use Eventbrite's OAuth 2.0 flow to obtain account-specific access tokens. However, for most use cases involving a single organizer account, the private token is sufficient and significantly simpler to configure. Note that Eventbrite's private tokens do not expire automatically, but you can revoke them from the API keys page if credentials are compromised.

In Retool, navigate to the Resources tab and click '+ Create new'. Select 'REST API' from the connector list. In the Name field, enter 'Eventbrite API'. For the Base URL, enter https://www.eventbriteapi.com/v3. For Authentication, select 'Bearer token' and paste your Eventbrite private token into the token field. Click 'Save resource'. Retool saves the configuration and makes it available to all apps in your organization. All requests are proxied server-side through Retool's backend, so the Bearer token is never transmitted to browser clients and CORS is not an issue. Once saved, test the connection by creating a quick GET query to /users/me/ — if it returns your Eventbrite account information, the token is working correctly. If your organization manages events across multiple Eventbrite accounts, create a separate REST API resource for each account with its corresponding private token, and name resources clearly (e.g., 'Eventbrite - Main Account', 'Eventbrite - Partner Account'). For production apps where token security is critical, store the private token as a secret configuration variable in Retool (Settings → Configuration Variables, mark as secret) and reference it in the resource using {{ retoolContext.configVars.EVENTBRITE_TOKEN }}.

Open your Retool app or create a new one. In the Code panel, click '+ New query' and select your Eventbrite API resource. Create a query to list all events for your organization: Method GET, path /organizations/{organization_id}/events/ — you can find your organization ID from the /users/me/ response (look for the 'organizations' array). Add URL parameters: status set to live,started,ended,complete for a broad view or just live for upcoming-only, time_filter set to current_future for events happening now or in the future, order_by set to start_asc, and page_size set to 50. Name this query getEvents. Create an attendees query: Method GET, path /events/{{ eventsTable.selectedRow.id }}/attendees/. Add parameters: page_size set to 100, page set to {{ attendeesTable.paginationOffset / 100 + 1 || 1 }}, and status set to attending for only confirmed attendees. Name this query getAttendees. Create a ticket classes query: Method GET, path /events/{{ eventsTable.selectedRow.id }}/ticket_classes/. Name this query getTicketClasses. Run each query to inspect the response structure — Eventbrite uses a pagination object with page_count, page_number, page_size, and object_count alongside the data array named after the resource type (events, attendees, ticket_classes).

1{
2  "method": "GET",
3  "path": "/organizations/YOUR_ORG_ID/events/",
4  "params": {
5    "status": "live,started",
6    "time_filter": "current_future",
7    "order_by": "start_asc",
8    "page_size": "50",
9    "expand": "ticket_availability"
10  }
11}

Eventbrite's API responses contain nested objects for dates, costs, venue, and custom form responses that need flattening before binding to Retool components. In the getEvents query editor, click 'Advanced' → toggle 'Transform results'. Write a transformer that maps each event in data.events to a flat row. Key fields: id, name.text for the event title, start.local for the local start time, end.local for the end time, status, capacity, and ticket_availability.quantity_sold if you used the expand parameter. For attendees, write a transformer on getAttendees that maps each attendee to a flat row: name, email, ticket class name, answers to custom questions (answers array where each item has question and answer fields), and checked_in boolean. Custom questions are stored in answers[n].answer — you need to know which question index corresponds to which question for your event's registration form. After writing transformers, drag two Table components onto the canvas. Set the first to {{ getEvents.data }} for the events list. Set the second to {{ getAttendees.data }} for the attendee list, configured to load when an event is selected. Enable server-side pagination on the attendees table with total row count from {{ getAttendees.rawData.pagination.object_count }}. Add KPI Text components above the attendees table showing total sold, total checked in, and check-in percentage calculated from the attendee data. For large event check-in tracking across multiple venues or time slots, and integration with badge printing or registration kiosks, RapidDev's team can help build a comprehensive Retool event operations solution.

1// Transformer: flatten Eventbrite attendees
2const attendees = data.attendees || [];
3return attendees.map(att => {
4  // Extract custom question answers
5  const answers = {};
6  (att.answers || []).forEach(a => {
7    answers[a.question.replace(/\s+/g, '_').toLowerCase()] = a.answer;
8  });
9  return {
10    attendee_id: att.id,
11    name: `${att.profile.first_name || ''} ${att.profile.last_name || ''}`.trim(),
12    email: att.profile.email,
13    company: att.profile.company || 'N/A',
14    job_title: att.profile.job_title || 'N/A',
15    ticket_class: att.ticket_class_name || att.ticket_class_id,
16    checked_in: att.checked_in,
17    check_in_time: att.checked_in
18      ? new Date(att.barcodes?.[0]?.changed || att.created).toLocaleString()
19      : 'Not checked in',
20    order_id: att.order_id,
21    ...answers
22  };
23});

For a production event operations dashboard, implement automatic data refresh and webhook-based real-time updates. For automatic refresh, select the getAttendees query in the Code panel, click the 'Advanced' tab, and enable 'Run query on a schedule'. Set the interval to 60000 ms (1 minute) for near-real-time check-in tracking during events. Also enable it on getEvents at 300000 ms (5 minutes) since events change less frequently. Add a manual 'Refresh Now' Button component at the top of the dashboard wired to trigger both queries simultaneously. For real-time webhook processing, create a Retool Workflow with a Webhook trigger. In Eventbrite's developer settings, configure webhooks to POST to your Retool Workflow's webhook URL for the 'attendee.checked_in' event type. The Workflow receives the payload and can write check-in data to a Retool Database table or trigger a notification to a connected Slack Resource. Bind a Table component in your Retool app to this Retool Database table to show a live stream of check-ins without relying on API polling. Add a Line Chart component showing check-in rate over time using the timestamped database records — this provides an event-floor display that shows check-in velocity trending up or plateauing during the event.