# Eventbrite Scraper & API: Events, Ticket Prices \[$0.50/1K] (`usefulapi/eventbrite-events`) Actor

Scrape Eventbrite events from many cities, categories and keywords in one run: dates (local and UTC), venues, coordinates, ticket prices, sold-out status, organizer stats. Free/paid and date filters, monitor mode for new and changed events. No proxy, no personal data. USD 0.50 per 1,000.

- **URL**: https://apify.com/usefulapi/eventbrite-events.md
- **Developed by:** [Useful API](https://apify.com/usefulapi) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 events

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Eventbrite Scraper and API: events data with ticket prices and organizers

Get Eventbrite events as clean rows for any city, country or online: title, start and end in local time and UTC, time
zone, venue, address, coordinates, neighbourhood, category, format and tags. Switch on event page details to add the
lowest and highest ticket price, currency, free or paid, sale status (on sale, sold out, sales ended) with Eventbrite's
own label (for example "Postponed"), age limit, refund policy and the organizer's public profile counters.

Search many locations, categories and keywords in one run, with duplicates removed across searches. Run it on a schedule
in **monitor mode** to see which events are new or changed since the last run.

**USD 0.50 per 1,000 events. Event page details USD 0.40 per 1,000. That is USD 0.90 per 1,000 fully detailed events.**
No API key, no Eventbrite account, no subscription.

### Why this one

- **Many cities, categories and keywords in one run**, duplicates removed across searches. Type cities the way you
  say them: New York, NYC, Austin, TX, Paris, France, London, UK.
- **Free or paid filter that works together with categories and dates** (for example paid music events this weekend).
- **Monitor mode:** schedule it and get only new or changed events, with the changed fields named (date, venue,
  price, sold out, cancelled). Unchanged events cost a tenth.
- **Ticket prices and sale status** straight from Eventbrite (prices as shown in the ticket list, fees included),
  Eventbrite's own label such as Postponed, age limit, refund policy.
- **Organizer counters for lead scoring** (events hosted, total attendees, years hosting, verified) without collecting
  anyone's email or phone.
- **Clean, flat rows:** local and UTC times with the time zone, coordinates, neighbourhood, the same columns on every row.
- **Polite and compliant:** robots.txt checked for every page, a declared user agent, no proxy, no personal data. Your
  runs are not slowed or billed for proxy traffic.

### Who it's for

- **Event aggregators and city guides:** a fresh feed of what is on, by city, category and date, with coordinates for maps.
- **Venues, promoters and ticketing teams:** watch competing events, ticket price ranges and sold-out events in your
  market; monitor mode tells you what changed since yesterday.
- **Market and tourism research:** count events by category, format, price band and neighbourhood across cities.
- **Sales teams selling to event organizers:** find active organizers and size them by events hosted and total attendees
  (public Eventbrite profile counters). No emails or phone numbers are collected.
- **Developers:** an Eventbrite events API you call from code, with the same columns on every row.

### What you get for each event

| Group | Fields |
|---|---|
| **Event** | eventId, url, name, summary (the one or two sentences shown in search results), category, subcategory, format, organizerTags, language, imageUrl (link), publishedAt, seriesId, isSeries |
| **When** | startLocal, endLocal, startUtc, endUtc, timezone, isCancelled |
| **Where** | isOnline, venueName, venueAddress, venueCity, venueRegion, venuePostalCode, venueCountry, neighbourhood, latitude, longitude |
| **Signals** | urgency (Eventbrite's search badges such as fewTickets), ticketsBy |
| **Event page details** (option, on by default) | priceMin, priceMax, currency, isFree, salesStatus (on_sale, sold_out, sales_ended, not_yet_on_sale...), salesMessage (Eventbrite's label, e.g. Postponed), eventStatus, ageRestriction, refundPolicy, hasExternalTickets, reservedSeating, organizerName, organizerUrl, organizerVerified, organizerEventsHosted, organizerTotalAttendees, organizerYearsHosting |
| **Monitor** (option) | changeType (new, changed, unchanged), changedFields |
| **Where it came from** | searchLocation, searchFor, searchUrl, scrapedAt, status, detailsStatus |

Every row has every column (empty values are `null`), so CSV and Excel exports line up.

| status | Meaning | Billed |
|---|---|---|
| `listed` | found on an Eventbrite search page | 1 event (+ details if read) |
| `event_page` | read from an event URL you gave | 1 event + details |
| `not_found` | the event URL no longer exists | no |
| `unavailable` | Eventbrite did not serve the event page after retries | no |

`detailsStatus` says whether the event page was read: `ok` (billed as details), `not_requested`, `not_found`,
`unavailable`, `unreadable`, `disallowed`, `not_read_run_stopping` (the run stopped first). Only `ok` is billed.

### How to search

**Locations:** type a city the way you say it, or a country, or `online`:

| You type | Eventbrite searches |
|---|---|
| New York (or NYC) | `ny--new-york` |
| Austin, TX | `tx--austin` |
| London (or London, UK) | `united-kingdom--london` |
| Paris, France | `france--paris` |
| Berlin | `germany--berlin` |
| United States | the whole country |
| online | online events worldwide |

Eventbrite matches a plain city name to its own place; the place it chose is in every row (`searchLocation`) and in
the run summary (`placesResolved`). To be exact, add the state or country ("Portland, OR"), use Eventbrite's own name
(`or--portland`, the part after `/d/` in its search URLs), or paste a whole search URL in **Eventbrite search URLs**
(its own filters are kept).

Each location is searched once per **category** (Eventbrite's 21 categories) and once per **keyword**. Add a **date**
(today, tomorrow, this weekend, this week, next week, this month, next month, or custom dates; either end can be left
open), **free or paid**, and **in person or online** if you like. Eventbrite shows at most 980 events per search (49 pages of 20); for more, split by category or by dates.

### Input examples

**Eventbrite scraper for one city** (music events in New York, with prices):

```json
{ "locations": ["New York"], "categories": ["music"], "maxEventsPerSearch": 200 }
```

**Events data for several cities in one run** (business and tech events next month, no event page details):

```json
{
  "locations": ["New York", "San Francisco, CA", "London, UK", "Berlin, Germany"],
  "categories": ["business", "science-and-tech"],
  "datePreset": "next-month",
  "maxEventsPerSearch": 980,
  "details": false
}
```

**Keywords and custom dates:**

```json
{ "locations": ["Chicago, IL"], "keywords": ["jazz", "wine tasting"], "datePreset": "custom", "startDate": "2026-12-01", "endDate": "2026-12-31" }
```

**Paid events in person this weekend:**

```json
{ "locations": ["Austin, TX"], "categories": ["music", "food-and-drink"], "datePreset": "this-weekend", "priceFilter": "paid", "eventFormat": "in-person" }
```

**Monitor: what is new or changed since yesterday** (schedule it daily in Apify):

```json
{ "locations": ["Austin, TX"], "categories": ["music"], "maxEventsPerSearch": 980, "monitor": "new_or_changed", "monitorName": "austin-music" }
```

**Specific events** (one row per event page):

```json
{ "eventUrls": ["https://www.eventbrite.com/e/some-event-tickets-1234567890"] }
```

### Eventbrite API: call it from code

Run it and get the rows back in one request (replace `YOUR_TOKEN` with your Apify API token):

```bash
curl -X POST "https://api.apify.com/v2/acts/usefulapi~eventbrite-events/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"locations":["New York"],"categories":["music"],"maxEventsPerSearch":50}'
```

Long runs: start the run with `/runs`, then read the dataset when it finishes. The run summary (rows per status, billed
events, per-search counts, why a run stopped early) is the `OUTPUT` record of the run's key-value store.

### Monitor mode

| Mode | What you get | Billing |
|---|---|---|
| Off | every event found | per event |
| Label | every event, with `changeType` (new, changed, unchanged) and `changedFields` | per event |
| Only new or changed | only events that are new or changed; unchanged ones are left out | per event delivered; unchanged USD 0.10 per 1,000 |

Compared fields: title, start, end, venue, address, cancelled, online, Eventbrite's search badges (`urgency`, e.g.
fewTickets); with event page details also prices, currency, sale status and event status. Unchanged events count
towards **Max events per search** and **Max events in total**. Direct event URLs are always returned (labelled). In "only new or changed" the search-page fields decide (the
event page is read only for events that are new or changed there), so a sell-out with no other change shows up in Label
mode with details on. The memory sits in a key-value store named `eventbrite-events-monitor` in your own Apify account,
one record per input (or per **Monitor name**, which keeps the memory when you edit the input), up to 15,000 events.
Events that ended more than two days ago are dropped from it.

### Pricing

Pay per event, nothing else:

| What | Price |
|---|---|
| Event (a row) | USD 0.50 per 1,000 |
| Event page details (price, sale status, organizer...) | USD 0.40 per 1,000 rows that get them |
| Unchanged event in monitor mode "only new or changed" | USD 0.10 per 1,000 |
| Run start | USD 0.002 per run |

Examples: 1,000 events without details USD 0.50; with details USD 0.90; a daily monitor of 980 events where 50 changed,
with details: USD 0.045 + USD 0.093 + start = about USD 0.14 a day. Online events left out by "In person only" are
not billed. Rows Eventbrite could not serve are not billed. Your
**maximum cost per run** is respected: the run stops by itself before it, with every row so far saved.

### Speed, and why it is polite

This tool reads Eventbrite the way a careful visitor would: one page at a time, search pages 10 seconds apart and event
pages 1.5 seconds apart, through Apify's normal servers (no proxy). It checks Eventbrite's robots.txt for every URL and
reads only pages robots.txt allows: search pages (`/d/...`) and event pages (`/e/...`), never Eventbrite's API, and never
follows a redirect off those pages or off Eventbrite.

- About **120 events a minute** without details.
- About **25 events a minute** with details (one event page each).

If Eventbrite says it is busy (HTTP 429), the run waits (1, then 3 minutes) and slows down; at the third 429 in a row,
or at once on HTTP 401 or 403, it stops and keeps the rows it has. Start the rest again later.

### Data and privacy

- No personal data: no emails, phone numbers, social links, performer names, attendee or buyer data. Email addresses,
  phone numbers, links and @handles inside the title and summary text are replaced (`[email removed]`,
  `[phone removed]`, `[link removed]`, `[handle removed]`); the summary is cut at 300 characters.
- Organizer = the name on the Eventbrite organizer profile, its public link and its public counters (events hosted,
  total attendees, verified).
- No full event descriptions and no copies of images: the summary from the search results and a link to the image.

### FAQ

**Is this the official Eventbrite API?** No. It reads Eventbrite's public web pages. Eventbrite's own API is for
organizers' apps and cannot be resold, so this tool does not use it.

**Do prices include fees?** They are the prices Eventbrite publishes for the event (its structured data), which on
the events we checked included Eventbrite's fee, as shown in the ticket list (for example USD 55.20 "incl. USD 5.20 fee").

**Why are some prices `null`?** Prices come from the event page, so switch on details. Some events hide prices or sell
through another site (`hasExternalTickets: true`).

**Why does a sold-out event say `on_sale`?** The sale status is Eventbrite's, per event. An event with several ticket types
or dates (`isSeries`) can still show on_sale while one date or type is sold out; check `salesMessage` and `urgency`.

**Why fewer events than Eventbrite's count?** Eventbrite's search stops at 49 pages (980 events). Split by category,
keyword or dates to reach more.

**Is it legal to scrape Eventbrite?** This tool collects public event information only, respects robots.txt and
collects no personal data. Eventbrite's terms of service restrict automated access and commercial use of its content;
you are responsible for how you use the data. If in doubt, ask a lawyer.

**Something is wrong or missing?** Open an issue on the Issues tab with the run link. We answer within a few days.

# Actor input Schema

## `locations` (type: `array`):

One place per line: a city (New York, NYC, Austin, TX, Paris, France, London, UK), a country (United States, Canada), or online for online events. Eventbrite's own place names also work (ny--new-york, united-kingdom--london: the part after /d/ in an Eventbrite search URL). Each location is searched for every category and keyword below; the place Eventbrite matched is shown in each row and in the run summary.

## `categories` (type: `array`):

Eventbrite's own categories. Pick none to get all events (or use keywords). Several categories are searched one by one, duplicates removed.

## `keywords` (type: `array`):

Free-text searches such as jazz, startup, yoga, wine tasting. Each keyword is a separate search in each location. Eventbrite does not combine a keyword with a category or with Free only.

## `datePreset` (type: `string`):

Date filter for every search. For keyword searches the preset is turned into start and end dates.

## `startDate` (type: `string`):

First day (when When = Custom dates). Leave empty to start today.

## `endDate` (type: `string`):

Last day (when When = Custom dates). Leave empty for one year after the first day.

## `priceFilter` (type: `string`):

Works with categories and all-events searches (also together with a date). Eventbrite ignores it for keyword searches.

## `eventFormat` (type: `string`):

In person only leaves out online events found in a city search (not billed). Online only keeps online events; with no location it searches Eventbrite's worldwide online catalog.

## `maxEventsPerSearch` (type: `integer`):

Per location x category or keyword. Eventbrite shows at most 49 pages of 20 per search (980); for more, split by category or dates.

## `maxEvents` (type: `integer`):

Stop after this many rows in the whole run. 0 = no limit (your maximum cost per run still applies).

## `details` (type: `boolean`):

Adds lowest and highest ticket price, currency, free or paid, sale status (on sale, sold out, sales ended), event status, age limit, refund policy, external ticketing, reserved seating, and the organizer's profile name, link, verified flag, events hosted and total attendees. One extra page per event, so runs take longer. No emails, phones or personal data are collected.

## `searchUrls` (type: `array`):

Search pages you set up on eventbrite.com (https://www.eventbrite.com/d/...), kept with their own filters. Pages are added automatically.

## `eventUrls` (type: `array`):

Direct event pages (https://www.eventbrite.com/e/...). Each becomes one row with the details above, billed as one event plus details. Pages that no longer exist come back with status not_found and are not billed.

## `monitor` (type: `string`):

Changes compared: title, start and end, venue, cancelled, online, few-tickets signal; with details on also ticket prices, currency, sale status and event status. Only new or changed compares the search-page fields (event pages are read only for new or changed events).

## `monitorName` (type: `string`):

Give a monitor a name to keep its memory when you edit the input; without a name the memory belongs to this exact input.

## Actor input object example

```json
{
  "locations": [
    "New York"
  ],
  "categories": [
    "music"
  ],
  "datePreset": "any",
  "priceFilter": "any",
  "eventFormat": "any",
  "maxEventsPerSearch": 20,
  "maxEvents": 0,
  "details": true,
  "monitor": "off"
}
```

# Actor output Schema

## `results` (type: `string`):

One row per event, same columns on every row. Download as CSV, Excel or JSON.

## `summary` (type: `string`):

Rows saved, duplicates and unchanged events skipped, billed events, Eventbrite requests, per-search counts and why the run stopped early (if it did).

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "locations": [
        "New York"
    ],
    "categories": [
        "music"
    ],
    "maxEventsPerSearch": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("usefulapi/eventbrite-events").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "locations": ["New York"],
    "categories": ["music"],
    "maxEventsPerSearch": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("usefulapi/eventbrite-events").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "locations": [
    "New York"
  ],
  "categories": [
    "music"
  ],
  "maxEventsPerSearch": 20
}' |
apify call usefulapi/eventbrite-events --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,usefulapi/eventbrite-events"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/tS6kfRsSWa5KsD0hL/builds/cIOr0mebkFM26mNgf/openapi.json