How to build Eventbrite event dashboards in Metabase

Eventbrite is the long-running ticketing and events platform — events, orders, attendees, ticket classes, and venues, with the richest commercial event data of any tool in this category. Metabase is where you turn that activity into shared, trustworthy event dashboards. This guide covers two complementary paths: a lightweight API + CLI route that pulls a scoped slice via the Eventbrite API v3 and loads a CSV into Metabase with the Metabase CLI, and a durable pipeline route that lands Eventbrite data in a database so you can build dashboards anyone can read.

How do you connect Eventbrite to Metabase?

Most teams combine both routes: quick answers through API exports and CLI uploads first, then recurring event reporting on a warehouse-backed model.

What can you analyze from Eventbrite data in Metabase?

These all come from the same core objects — attendees, plus the events, orders and ticket classes, venues your sync exposes:

• Registrations and ticket revenue by event
• RSVP-to-attendance conversion and no-show rate
• Ticket class mix and pricing performance
• Registration pacing and last-week surge
• Repeat attendees across an event series

Which Eventbrite event dashboards should you build in Metabase?

How do you export Eventbrite data and load it with the Metabase CLI?

There is no vendor MCP server for Eventbrite, so pair a scripted export against the Eventbrite API v3 with the Metabase CLI. The export gives you a CSV; the CLI's upload command loads it into Metabase and creates a ready-to-query table and model.

Example workflow

• Ask the API for attendees for every event in the last year, one row per attendee with registration and check-in timestamps.
• Export the result as CSV, keeping stable IDs, timestamps, and the category, space, channel, or event keys you group by.
• Run mb upload csv to load it into Metabase as a table and model, then build questions and dashboards on top.

Be honest about the limits

• Scripted API exports are excellent for exploration, not scheduled reporting.
• A CSV upload is a snapshot; refresh it with mb upload replace or move to the pipeline for real history.
• One event is a data point, not a trend. Ticket-mix, pacing, and repeat-attendee views need a full series of past events, with orders and refunds included.
• mb upload csv needs an uploads database configured under Admin → Settings → Uploads.

How do you set up the Eventbrite API v3 export and the Metabase CLI?

# No vendor MCP server exists. Export directly from API v3 instead:
curl -s "https://www.eventbriteapi.com/v3/events/$EVENT_ID/attendees/" \
  -H "Authorization: Bearer $EVENTBRITE_TOKEN" \
  | jq -r '.attendees[] | [.id, .event_id, .status, .created,
      .checked_in, .ticket_class_name] | @csv' \
  > eventbrite-attendees.csv

Eventbrite publishes no MCP server (verified July 2026). Several community projects wrap API v3 with a private token; none is authoritative, so this guide leads with a scripted export against the documented API. One thing to know before you evaluate any of them: Eventbrite removed public event search from the API years ago, so a server advertising "search all events" is either scraping or is limited to events your own organization owns.

# Install the Metabase CLI
npm install -g @metabase/cli

# Log in (opens your browser; requires Metabase v62+)
mb auth login --url https://your-metabase.example.com

# Load a attendees export — creates a table AND a model
mb upload csv --file eventbrite-attendees.csv --collection root

# Refresh that same table later from a new export
mb upload replace <table-id> --file eventbrite-attendees.csv

Can you generate a Eventbrite dashboard with AI?

Yes. Use the prompt below with any assistant that can run shell commands (for the API export) and the Metabase CLI. It works end to end: if Eventbrite tables already exist in Metabase it analyzes those; otherwise it pulls scoped, summarized data, loads it with mb upload csv, then builds the dashboard and caveats any metric that needs missing history.

Create a polished Metabase dashboard for Eventbrite event analytics.
Work end to end: get the data into Metabase if it isn't there yet, then build.

Goal: Help community, marketing, and support leaders understand registrations, RSVP-to-attendance conversion, ticket revenue net of refunds, and repeat attendance from Eventbrite data.

Step 1 — Find or load the data:
- First, check what already exists in Metabase (search for eventbrite tables and
  models). If durable Eventbrite data is already present — a warehouse sync, a
  database replica, or an earlier upload — use it and skip to Step 2.
- If nothing is there, pull a scoped, summarized export by scripting the Eventbrite API v3:
  attendees, plus events, orders and ticket classes, venues.
  Prefer summarized rollups by month, category, space, channel, or event over raw
  message and post bodies. Write each result to a CSV, then load it with the
  Metabase CLI — run "mb upload csv --file <export>.csv" so each upload creates a
  table and a ready-to-query model. Use "mb upload replace <table-id> --file
  <export>.csv" to refresh an existing table instead of creating duplicates.

Step 2 — Inspect before querying:
Do not assume exact table or column names. Inspect available fields, categories,
spaces or channels, events, and date ranges before creating trend cards.

Important:
- Build on whatever data is present; don't claim Metabase connects natively to
  Eventbrite — it reads a database or CLI-uploaded tables.
- Every "active member" card must state its window and its action (posted?
  logged in?) in the card title or description. There is no standard definition.
- Deleted and anonymized accounts disappear from the current member list, which
  silently rewrites historical member counts. Prefer daily snapshots over
  recomputing history.
- Attendance is unknowable without check-in data. Exclude events where nobody
  checked anyone in rather than scoring them as 0% attendance.
- A single CSV is a point-in-time snapshot: only build trend cards if there is
  a usable date column or multiple periods have been uploaded.

Dashboard title: Eventbrite Event Overview

Sections:
1. Executive summary: Registrations this period; Attendance rate
   (check-in data only); Net ticket revenue; Repeat attendees;
   Events with no check-in data.
2. Registrations: By event and by month; ticket class mix; capacity fill.
3. Attendance: Conversion by event; no-show rate; check-ins by hour.
4. Revenue: Gross, fees, refunds, and net by event; net per attendee.
5. Series: Repeat attendees; registration pacing; attendance trend.

Filters: Date range, Category or Space or Channel, Event, Member segment,
Ticket type.

Output: Build the dashboard if you have permission; otherwise provide the exact
questions, SQL, model definitions, and layout. Include caveats for any metric
that cannot be calculated from the available data.

How do you sync Eventbrite data into a database or warehouse?

For dashboards that need history and reliability, land Eventbrite data in a database first, then connect Metabase to that database.

Connector options

• Managed connector or database replica — use a connector when one genuinely covers the objects you need, or replicate the underlying database when you host it yourself.
• Custom pipeline — use the Eventbrite API v3 for control over grain, fields, and refresh cadence.
• API + CSV — use this for quick exploration and one-off slices.

This is the best-connected tool in the category. Airbyte's source-eventbrite (Marketplace support level) syncs organizations, events, attendees, orders, venues, and ticket classes with incremental support on most streams; Fivetran offers an Application Lite connector, so confirm its schema covers orders and attendees if revenue reporting matters. Scripting API v3 yourself is straightforward too — use expansions to inline related objects and cut your request count substantially.

Notes

• Decide the grain first (one row per post, message, or registration; daily rollups on top) — it drives every trend card.
• Land raw tables first, then build clean Metabase models on top of them.
• Normalize event, attendee, order, ticket-class, registered-at, and checked-in-at fields.

How should you model Eventbrite data in Metabase?

Core tables

Modeling advice

• Build a clean event_registrations model with common columns across forums, community platforms, chat servers, and event tools, so multi-source dashboards don't fork definitions.
• Snapshot member counts daily into a table you own. Deleted and anonymized accounts vanish from the live member list, which changes last quarter's numbers every time you refresh.
• Keep the definition of "active member" — the window and the action — in the model layer, and surface it in card titles. There is no standard.
• Treat attendance as missing, not zero, when no check-in was recorded. Flag those events explicitly so conversion cards can exclude them.
• Hash or drop email addresses at the pipeline boundary and join members across tools on a stable ID wherever you have one.

Which Eventbrite event metrics should you track in Metabase?

What SQL powers Eventbrite event dashboards in Metabase?

These assume a cleaned analytical model in a warehouse (PostgreSQL dialect). Adjust table and column names to match your pipeline — the modeled names above rarely survive a sync unchanged.

-- Events where nobody checked anyone in return NULL, not 0%.
SELECT
  e.name AS event,
  e.starts_at::date AS event_date,
  COUNT(*) AS registered,
  COUNT(r.checked_in_at) AS checked_in,
  CASE
    WHEN COUNT(r.checked_in_at) = 0 THEN NULL
    ELSE ROUND(100.0 * COUNT(r.checked_in_at) / NULLIF(COUNT(*), 0), 1)
  END AS attendance_pct
FROM community_events e
JOIN event_registrations r ON r.event_id = e.event_id
WHERE e.starts_at < CURRENT_DATE
GROUP BY 1, 2
ORDER BY 2 DESC;

SELECT
  e.name AS event,
  COUNT(DISTINCT o.order_id) AS orders,
  SUM(o.ticket_count) AS tickets,
  ROUND(SUM(o.gross_amount), 2) AS gross_revenue,
  ROUND(SUM(o.fees), 2) AS fees,
  ROUND(SUM(o.refunded_amount), 2) AS refunds,
  ROUND(SUM(o.gross_amount - o.fees - o.refunded_amount), 2) AS net_revenue
FROM event_orders o
JOIN community_events e ON e.event_id = o.event_id
GROUP BY 1
ORDER BY net_revenue DESC;

WITH attended AS (
  SELECT
    guest_id,
    COUNT(DISTINCT event_id) AS events_attended
  FROM event_registrations
  WHERE checked_in_at IS NOT NULL
  GROUP BY guest_id
)
SELECT
  events_attended,
  COUNT(*) AS guests
FROM attended
GROUP BY events_attended
ORDER BY events_attended;

What are common mistakes when analyzing Eventbrite in Metabase?

Related

Related analytics

Related dashboards

Related integrations

FAQ