Eventbrite

Go to eventbrite.com and log in to your organizer account. Click your profile picture in the top-right corner and select 'Account Settings' from the dropdown. In the Account Settings page, scroll down to the 'Developer Links' section in the left sidebar and click 'API Keys.' If you don't see this section, look for a direct link at eventbrite.com/platform/api-keys. On the API Keys page, click 'Create API Key.' Give your key a name (for example, 'Bubble App Integration') and click 'Create Key.' You'll see your new API key on the page — this is your private API token. Important characteristics of Eventbrite private tokens: - They are account-scoped: a single token sees ALL your events, ALL your attendees, and ALL your ticket data. This is powerful but means if the token is compromised, everything is exposed. - They don't expire automatically — they remain valid until you revoke them from this same API Keys page. - For multiple Bubble apps, generate a separate token per app. This limits blast radius if one token is compromised — you can revoke just that token without affecting your other apps. Copy the token and keep it ready to paste into Bubble. Never put it in a Bubble page element, URL parameter, or email — only in the API Connector's Private header.

In your Bubble editor, click 'Plugins' in the left sidebar → 'Add plugins' → search 'API Connector' (by Bubble) → Install. Click 'API Connector' in your plugins list → 'Add another API.' Name it 'Eventbrite.' Set the 'API Root URL' to `https://www.eventbriteapi.com/v3`. Under 'Shared headers,' add one header: - Key: `Authorization` - Value: `Bearer YOUR_PRIVATE_TOKEN_HERE` (replace with your actual token) - Check the **'Private'** checkbox — this ensures the token is server-side only Before building event-specific calls, verify the connection with a simple test. Add a first call named 'Get My Profile.' Set method to GET, path to `/users/me/`. Under 'Use as,' select 'Data.' Click 'Initialize call.' A successful response returns your Eventbrite account profile including `id`, `name`, `first_name`, `last_name`, `email`, and `url`. Seeing your account details confirms the token is valid and the connection is working. If Initialize returns 'There was an issue setting up your call' or a 401 error: verify the Authorization header is exactly `Bearer ` followed by the token (with a space after Bearer), and that the Private checkbox is checked. Also confirm you're using the correct API Root URL — `https://www.eventbriteapi.com/v3` with the version path included.

1{
2  "api_name": "Eventbrite",
3  "base_url": "https://www.eventbriteapi.com/v3",
4  "shared_headers": [
5    {
6      "key": "Authorization",
7      "value": "Bearer <private: your_eventbrite_private_token>",
8      "private": true
9    }
10  ],
11  "test_call": {
12    "name": "Get My Profile",
13    "method": "GET",
14    "path": "/users/me/",
15    "use_as": "Data",
16    "expected_response_fields": ["id", "name", "email", "url"]
17  }
18}

Eventbrite's API is organized around organizations (your organizer account) and events within them. Most event queries require your organization ID — a unique identifier that groups all your events. Add a second call: name it 'Get My Organizations,' method GET, path `/users/me/organizations/`. Use as 'Data.' Initialize it. The response returns an `organizations` array where each item has `id`, `name`, and other metadata. Your organization ID is the `id` field of the first (or only) item in this array. Save your organization ID as a Bubble App Constant: go to Settings → Bubble's 'Site Variables' or add a Data type called 'App Settings' with one record containing an `eventbrite_org_id` Text field. Store the value there. This avoids repeating a round-trip API call every time you need the org ID. Now add the events call: name it 'Get Events,' method GET, path `/organizations/{org_id}/events/`. Mark `org_id` as a dynamic parameter. Add URL parameters: - `status`: optional, default `live` (other options: `draft`, `canceled`, `ended`, `completed`, `all`) - `time_filter`: optional, default `current_future` (options: `current_future`, `past`, `all`) - `expand`: add `ticket_availability` — this single parameter adds sold/remaining ticket counts to each event object, saving a separate API call per event - `page_size`: set `50` Initialize with your actual org ID from the previous call. The response includes an `events` array with each event's `id`, `name.text`, `start.local`, `end.local`, `url`, `capacity`, `ticket_availability` (sold count, remaining), and `status`.

1{
2  "call_name": "Get Events",
3  "method": "GET",
4  "path": "/organizations/<org_id>/events/",
5  "parameters": [
6    { "key": "status", "value": "live", "optional": true },
7    { "key": "time_filter", "value": "current_future", "optional": true },
8    { "key": "expand", "value": "ticket_availability" },
9    { "key": "page_size", "value": "50" },
10    { "key": "page", "value": "<dynamic>", "optional": true }
11  ],
12  "sample_event_fields": [
13    "id",
14    "name.text",
15    "start.local",
16    "end.local",
17    "url",
18    "capacity",
19    "status",
20    "ticket_availability.quantity_total",
21    "ticket_availability.quantity_sold"
22  ]
23}

To build a check-in app or attendee management interface, add an attendees call. Name it 'Get Attendees,' method GET, path `/events/{event_id}/attendees/`. Mark `event_id` as dynamic. Add parameters: - `page_size`: `50` - `page`: dynamic (for pagination) - `status`: optional filter (`attending`, `not_attending`, `attended`) Initialize with a real event ID from your account. The response returns an `attendees` array. Each attendee has: `id`, `profile.name`, `profile.first_name`, `profile.last_name`, `profile.email`, `profile.cell_phone`, `ticket_class_name`, `status` (attending/checked_in), `checked_in` (boolean), `created`, and `answers` (array of custom registration form answers). **CRITICAL — Privacy rules:** Before saving any attendee data to Bubble's database, you must configure Privacy rules. Go to Data tab → Privacy → click your Attendee data type. Add a rule: 'Everyone else' → uncheck ALL permissions (View, Edit, Delete). Add a rule: 'Current User (who is an admin)' → grant View and Edit. Attendees' email addresses, phone numbers, and registration answers are personal data protected by GDPR and similar regulations. Bubble's default 'everyone can view' setting would expose all attendees' personal data through the Data API. For the attendee Repeating Group: add search constraints to show only attendees for the currently selected event. Add a filter input for searching by name. Add a 'Check In' button per row that updates a `checked_in` boolean field on the Attendee record in Bubble's database and updates a checked-in count custom state on the page. For pagination: Eventbrite uses a `pagination` object in every response with `page_count`, `page_number`, `page_size`, and `object_count`. Add 'Previous' and 'Next' buttons that increment/decrement a `current_page` custom state and pass it as the `page` parameter.

1{
2  "call_name": "Get Attendees",
3  "method": "GET",
4  "path": "/events/<event_id>/attendees/",
5  "parameters": [
6    { "key": "page_size", "value": "50" },
7    { "key": "page", "value": "<dynamic: current page number>", "optional": true },
8    { "key": "status", "value": "attending", "optional": true }
9  ],
10  "key_attendee_fields": [
11    "id",
12    "profile.name",
13    "profile.email",
14    "ticket_class_name",
15    "status",
16    "checked_in",
17    "created",
18    "answers"
19  ],
20  "privacy_rule_reminder": "Set 'Everyone else' to NO permissions on Attendee data type before saving any attendee records"
21}

For selling tickets inside your Bubble page without any API configuration, use Eventbrite's official checkout widget. This is a separate capability from the REST API — it doesn't require the private token. Find your event ID: open your event on eventbrite.com and look at the URL. The format is `https://www.eventbrite.com/e/event-name-tickets-{EVENT_ID}`. The long number at the end is your event ID. In your Bubble editor, add an HTML element to the page where you want the widget to appear. Set its height to at least 400 pixels. Paste the following HTML, replacing `{EVENT_ID}` with your actual event ID: The widget loads Eventbrite's complete checkout flow inline — ticket type selection, quantity, and payment processing. It handles all Stripe/payment logic. You receive ticket sales in your Eventbrite account normally. To make the event ID dynamic (showing different events based on the page or user), use Bubble's dynamic content in the HTML element. Store the Eventbrite event ID in a Bubble data field (on your Event or Campaign data type) and construct the widget HTML dynamically using Bubble's text expression: paste the static parts of the script with `+` concatenating the dynamic event ID field from your data. Note: the widget is for publicly listed events. Private events with invite-only access require a different embed approach using Eventbrite's private access link — check eventbrite.com support documentation for private event embed options.

1<!-- Eventbrite ticket checkout widget -->
2<!-- Replace EVENT_ID with your actual Eventbrite event ID -->
3<!-- Find your event ID in the URL: eventbrite.com/e/your-event-tickets-{EVENT_ID} -->
4
5<div id="eventbrite-widget-container-EVENT_ID"></div>
6
7<script src="https://www.eventbrite.com/static/widgets/eb_widgets.js"></script>
8
9<script type="text/javascript">
10  var exampleCallback = function() {
11    console.log('Order complete!');
12  };
13
14  window.EBWidgets.createWidget({
15    widgetType: 'checkout',
16    eventId: 'EVENT_ID',
17    iFrameContainerId: 'eventbrite-widget-container-EVENT_ID',
18    iFrameContainerHeight: 425,
19    onOrderComplete: exampleCallback
20  });
21</script>
22
23<!-- Dynamic version tip: use Bubble's HTML element dynamic content -->
24<!-- Replace EVENT_ID in both the div id and the eventId value with your dynamic field -->

For real-time notifications when someone buys a ticket — to trigger a welcome email, add them to a Bubble user record, or update a dashboard counter — set up an Eventbrite webhook pointing to a Bubble Backend Workflow. This requires a paid Bubble plan. First, go to Bubble's Settings → API tab and check 'This app exposes a Workflow API.' Then go to the Backend Workflows editor and create a new workflow. Name it 'eventbrite_webhook.' Add parameters to receive the webhook data: `api` (text) and `payload` (text or auto-detect). Under 'Detect request data,' save an empty workflow first. Your Backend Workflow endpoint URL will be: `https://yourapp.bubbleapps.io/api/1.1/wf/eventbrite_webhook` Now register this URL in Eventbrite. Go to eventbrite.com → Account Settings → Developer Links → Webhooks → Create Webhook. Enter your Backend Workflow URL and select the events you want to receive. For ticket purchases: select `attendee.updated` (fires when attendee status changes) and `order.placed` (fires when an order is completed). Eventbrite sends a POST to your URL with a JSON payload containing the event type and the affected object ID. In your Backend Workflow, after detecting the data structure, add steps to: look up the attendee or order by ID from the payload, fetch their details from the Eventbrite API (using the ID from the webhook), create or update the attendee record in Bubble's database, and trigger a confirmation email workflow. Note: For free-plan Bubble apps, an alternative is polling — a scheduled page workflow that checks for new attendees every 15 minutes by querying `/events/{id}/attendees/?page_size=50&status=attending` and comparing against records already in Bubble's database.

1{
2  "backend_workflow_endpoint": "https://yourapp.bubbleapps.io/api/1.1/wf/eventbrite_webhook",
3  "webhook_payload_example": {
4    "config": {
5      "action": "order.placed",
6      "user_id": "12345678",
7      "endpoint_url": "https://yourapp.bubbleapps.io/api/1.1/wf/eventbrite_webhook"
8    },
9    "api_url": "https://www.eventbriteapi.com/v3/orders/1234567890/"
10  },
11  "webhook_processing_steps": [
12    "Step 1: Receive webhook payload, extract api_url from payload",
13    "Step 2: Call Eventbrite API to fetch order/attendee details from the api_url",
14    "Step 3: Create Attendee record in Bubble DB with fetched details",
15    "Step 4: Apply Privacy rules — restrict attendee visibility to event admin only",
16    "Step 5: Trigger welcome email workflow"
17  ],
18  "paid_plan_note": "Backend Workflows require Bubble Starter or higher plan"
19}