# Eventbrite Events Scraper (`deriverge/eventbrite-scraper`) Actor

Public Eventbrite events for a city, keyword and date range, with venue, category, organizer page and ticket link on every row. Turn on event details for organizer names, ticket prices and sold-out status. Searches are split by day to get past the 980 results Eventbrite shows per search.

- **URL**: https://apify.com/deriverge/eventbrite-scraper.md
- **Developed by:** [deriverge s.r.o.](https://apify.com/deriverge) (community)
- **Categories:** Travel, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.75 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Events Scraper

Eventbrite Events Scraper collects the public events Eventbrite lists for a place, one row per event: name, summary, dates and times, venue with address and coordinates, category, format, tags, ticket link and a link to the organizer's page. Type a city such as `London`, a location slug such as `united-states--new-york`, or paste an Eventbrite search link, then click **Start**. Organizer names and ticket prices need **Include event details**, which opens every event page and adds up to a second per event to a run. It costs $1.50 per 1,000 events on the Free plan ($0.75 on Business), and the $5 of monthly credit in Apify's Free plan covers about 3,300 events.

### What data does it return?

| Field | Description |
|---|---|
| `eventId`, `url` | Eventbrite's event ID and the public event page. The domain varies from event to event, for example eventbrite.com or eventbrite.de. |
| `name`, `summary` | Event title and the short summary the organizer wrote for it. |
| `startDate`, `startTime`, `endDate`, `endTime` | Local dates as `YYYY-MM-DD` and times as `HH:MM` on a 24-hour clock, such as `2026-10-16` and `17:00`. |
| `timezone` | Time zone of the venue, such as `Europe/Berlin`. |
| `isOnline`, `isCancelled` | `true` for online-only events and for events Eventbrite marks as canceled. |
| `venueName`, `venueAddress` | Venue and its full address as Eventbrite displays it. |
| `city`, `region`, `country` | City, region as Eventbrite writes it, such as `BE` for Berlin or `Hlavní město Praha` for Prague, and two-letter country code such as `DE`. The region is sometimes empty. |
| `latitude`, `longitude` | Coordinates of the venue in decimal degrees. |
| `organizerId`, `organizerUrl` | Numeric ID of the organizer and the organizer's public Eventbrite page, such as `https://www.eventbrite.com/o/67827762883`. Contact details of organizers are not collected. |
| `imageUrl`, `ticketsUrl` | The event image in its original size and the link to Eventbrite's ticket checkout. |
| `tags` | Eventbrite's category labels and the event format, such as `Music` and `Party or Social Gathering`, followed by the organizer's own tags. |
| `sourceDate` | The day of the split search that found the event, or `null` when the search was not split by day. |
| `sourceCategory` | Always `null` since Eventbrite stopped serving category searches. |
| `scrapedAt` | When the event was read, as an ISO 8601 UTC timestamp. |
| `category`, `subcategory`, `format` | Eventbrite's category, subcategory and event format as separate values, such as `Food & Drink`, `Beer` and `Festival or Fair`. The subcategory is often empty. |
| `language`, `publishedAt` | Language of the listing, such as `de-de`, and when the organizer published the event. |
| `postalCode`, `venueId` | Postal code of the venue and Eventbrite's venue ID, which is the same for every event held there. |
| `seriesId` | ID of the parent event when the event is one date of a series, otherwise `null`. |
| `urgencySignals` | Labels from the event card: `fewTickets`, `goingFast`, `salesEndSoon`, `new` or `popular`. Empty for most events. |
| `isFree` | `true` for free events and `false` for paid ones. Filled when **Price** is set, when the actor split the search into free and paid events, or with event details on; otherwise `null`. |
| `organizerName` | Organizer name from the event page, given only for organizations and public organizer pages. Needs event details. |
| `priceMin`, `priceMax`, `priceCurrency` | Lowest and highest ticket price on the event page and its currency, such as `27.71`, `64.99` and `EUR`. Needs event details. |
| `ticketAvailability`, `isSoldOut` | `InStock` or `SoldOut` as the event page states it, and `true` for sold-out events. Needs event details. |
| `eventStatus` | Status from the event page, such as `EventScheduled`, `EventCancelled` or `EventPostponed`. Needs event details. |
| `detailFetched` | `true` when the event page was read, `false` when it could not be read, `null` with event details off. |

### How to scrape Eventbrite events

1. In **Location**, type a city such as `London` or `Berlin, Germany`, the part of an Eventbrite search address after `/d/` such as `united-kingdom--london`, or a whole search link. The log shows which Eventbrite place a city name matched, and a link also sets the keyword, price filter and dates unless you fill them yourself.
2. To narrow the search, fill **Keyword** (such as `jazz` or `tech meetup`) and set **Price** to free or paid events only.
3. Enter **Start date** and **End date** as `YYYY-MM-DD`, or as moving dates like `today` and `+30` that keep a saved task current. A start date alone gets an end 365 days later; an end date alone starts today.
4. Turn on **Include event details** for organizer names, ticket prices and sold-out status, and set **Maximum events** to cap the cost.
5. Click **Start**. The **Output** tab lists the events, has an **Organizers and prices** view and exports to CSV, Excel or JSON. The `COVERAGE_REPORT` record in the key-value store says whether every day was read in full. Over the API, the input looks like this:

```json
{
  "place": "Berlin, Germany",
  "keyword": "techno",
  "price": "paid",
  "dateFrom": "today",
  "dateTo": "+21",
  "includeDetails": true,
  "maxItems": 500
}
```

### Example output

One event from a Berlin run on 11 October 2026 with event details on. The 8-day range fit into one search, so `sourceDate` is `null`.

```json
{
  "eventId": "1990439872239",
  "url": "https://www.eventbrite.de/e/oktoberfest-2026-im-cafe-am-neuen-see-freitag16-oktober-tickets-1990439872239",
  "name": "Oktoberfest 2026 im Café am neuen See - Freitag16. Oktober",
  "summary": "Das Café am Neuen See lädt ein zum Oktoberfest: Genießt bayerische Leckereien, Live-Musik und festliche Stimmung direkt am See.",
  "startDate": "2026-10-16",
  "startTime": "17:00",
  "endDate": "2026-10-16",
  "endTime": "23:00",
  "timezone": "Europe/Berlin",
  "isOnline": false,
  "isCancelled": false,
  "venueName": "Café am Neuen See",
  "venueAddress": "Lichtensteinallee 2, 10787 Berlin",
  "city": "Berlin",
  "region": "BE",
  "country": "DE",
  "latitude": 52.5103772,
  "longitude": 13.3444862,
  "organizerId": "67827762883",
  "imageUrl": "https://img.evbuc.com/https%3A%2F%2Fcdn.evbuc.com%2Fimages%2F1185467302%2F1065220308193%2F1%2Foriginal.20250704-074815?auto=format%2Ccompress&q=75&sharp=10&s=5ce37c8ecedf85c942740b7c8f5d3cf3",
  "ticketsUrl": "https://www.eventbrite.com/checkout-external?eid=1990439872239",
  "tags": [
    "Beer",
    "Food & Drink",
    "Festival or Fair",
    "Beer",
    "Event",
    "Oktoberfest",
    "Cafe",
    "neuensee"
  ],
  "sourceCategory": null,
  "sourceDate": null,
  "scrapedAt": "2026-10-11T13:49:19.736Z",
  "organizerUrl": "https://www.eventbrite.com/o/67827762883",
  "category": "Food & Drink",
  "subcategory": "Beer",
  "format": "Festival or Fair",
  "language": "de-de",
  "publishedAt": "2026-05-26T19:55:25Z",
  "postalCode": "10787",
  "venueId": "297906858",
  "seriesId": null,
  "urgencySignals": [
    "fewTickets"
  ],
  "isFree": false,
  "organizerName": "Café am Neuen See",
  "priceMin": 27.71,
  "priceMax": 64.99,
  "priceCurrency": "EUR",
  "ticketAvailability": "InStock",
  "isSoldOut": false,
  "eventStatus": "EventScheduled",
  "detailFetched": true
}
```

### How much does it cost to scrape Eventbrite events?

| | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| 1,000 events | $1.50 | $1.20 | $0.975 | $0.75 |

You pay only for the events in the table. There is no start fee, and compute time and proxies are included.

A run for Madrid over the next 30 days returned 615 events on 23 September 2026, which costs $0.9225 on the Free plan and $0.46125 on Business. Event details do not change the price per event. Events outside your date range or without your keyword are dropped before charging, and an event that several searches find is charged once.

### Limits

- One Eventbrite search shows at most 49 pages of 20 events, 980 in total. The actor splits the search by day and then into free and paid events. A day that still has more than 980 free or paid events stays incomplete: Eventbrite counted 1,660 paid events in New York for 5 September 2026. The coverage report lists every such day with Eventbrite's count and the reachable 980.
- Without dates, the search can only be split into free and paid events, so a run reaches at most 1,960 events. For New York, Eventbrite counted 14,787 events without a date range on 26 September 2026. With **Price** set, the free and paid split is gone, so each search or day reaches at most 980 events.
- Eventbrite's own counts stop at 10,000 per search, so the coverage report underestimates what a very large city holds.
- Planning makes at most 300 checks and splits a range into at most 400 days. In a busy city, days past the 300th check can come back incomplete without a line in the coverage report, and days after the 400th are not read. Run long ranges a few months at a time.
- Planning a long range in a big city takes time, because the actor checks each day first and waits between requests: New York from September to December 2026 took about six minutes.
- Eventbrite sorts its search by the keyword but does not filter by it: `jazz` in New York lists every event in the city, closest matches first. The actor keeps events whose name, summary or tags contain every word and stops after 3 pages in a row without a match, so events with the keyword only in their full description are missed. On 11 October 2026, `jazz` in New York for 11 to 25 October kept 89 events from 14 search pages and skipped 191 others.
- A city name is matched by Eventbrite itself, and a name several places share gives the one Eventbrite picks: `Springfield` became Springfield, Illinois on 11 October 2026. Add the state or country, as in `Springfield, MA`, or use the slug when the log shows the wrong place.
- Words for dates in a pasted link, such as `this-weekend`, become dates in UTC and can be one day off near midnight. A category in a link, such as `music--events`, is searched as the keyword `music`.
- With event details on, the actor opens every event page one at a time. On 11 October 2026, 20 events from New York took 19 seconds with event details and 8 seconds without, and 100 events from London over 30 days took 237 seconds against 163. If Eventbrite refuses event pages, the run stops and says so in the log and the coverage report.
- Prices come from the data the event page gives search engines, and 85 of 100 London events had them on 11 October 2026. Donation tickets show a price of `0` with `isFree` set to `false`. `SoldOut` also marks events whose ticket sales have ended, which is common on the day of the event.
- Only events that appear in Eventbrite's public search are returned. Event pages are opened only with event details on, and ticket forms never.
- If Eventbrite changes its search page so that the event data is missing, the run fails with an error.

### FAQ

#### Is it legal to scrape Eventbrite?

The actor reads the public search pages that Eventbrite shows to any visitor and, with event details on, the public event pages, and stores the event listings from them. It does not collect attendee or buyer data or organizer contact details, and it gives organizer names only for organizations and public organizer pages. You are responsible for how you use the results.

#### How do I get a list of event organizers in a city?

Run the actor for the city and a date range, then group the rows by `organizerId`. Every row links the organizer's public Eventbrite page in `organizerUrl`, and **Include event details** adds the organizer name. The **Organizers and prices** view in the **Output** tab shows organizer, category and ticket prices side by side.

#### Why does the coverage report count more events than I received?

`declaredByEventbrite` adds up Eventbrite's own counts for every search the actor planned. A run returns fewer events when **Maximum events** stops it first or when some days hold more than a search can show; `slicesTruncated`, `truncatedSlices` and `estimatedUnreachable` tell you where. For keyword searches `declaredByEventbrite` and `estimatedUnreachable` are `null`, because Eventbrite counts every event in the place, and `skippedWithoutKeyword` says how many events did not contain the keyword.

#### Can I filter by category or price?

Price yes: set **Price** to free or paid events. Eventbrite's category pages stopped carrying search data on 30 August 2026, so there is no category filter, and an input with `categories` stops with an error. Put the category name in **Keyword**, such as `music` or `food and drink`, which keeps events with that category label, or filter the `category` field after the run.

### Related scrapers

- [Meetup Events Scraper](https://apify.com/deriverge/meetup-scraper)
- [Luma Events Scraper](https://apify.com/deriverge/luma-events-scraper)

### Support

This actor is built and maintained by deriverge s.r.o., a software company based in the Czech Republic. If a run fails or a field you need is missing, please open an issue in the **Issues** tab or write to us at info@deriverge.com. We respond in English and Czech. Runs can be scheduled in Apify Console or started from the **API** tab, which has examples for Python, JavaScript and cURL and works with Make, Zapier, n8n and the Apify MCP server. If the actor saves you time, a short review helps other people find it.

# Changelog

This Actor's version history is a separate document: https://apify.com/deriverge/eventbrite-scraper/changelog.md

# Actor input Schema

## `place` (type: `string`):

City name, Eventbrite location slug, or a pasted Eventbrite search link. A city name such as London or "Berlin, Germany" is looked up on Eventbrite and the log shows the place it matched. The slug is the part of an Eventbrite search address after /d/, for example united-states--new-york, united-kingdom--london or czech-republic--praha. From a pasted link such as https://www.eventbrite.com/d/ny--new-york/free--events/jazz/ the actor also takes the keyword, the free or paid filter and the dates, unless you fill those fields below.

## `keyword` (type: `string`):

Keep only events whose name, summary or tags contain every word, for example jazz, yoga or tech meetup. Eventbrite sorts its search by the keyword, and the actor reads it page by page until matches run out. Events without the keyword are skipped and not charged. Leave empty for all events in the location.

## `price` (type: `string`):

Only free events, only paid events, or both.

## `dateFrom` (type: `string`):

Set both dates or neither. Eventbrite ignores one-sided ranges, so a missing boundary is filled in automatically and reported in the log. Use YYYY-MM-DD. You can also give a moving date instead of a fixed one: today, tomorrow, yesterday, or a day offset such as +30 or -7. A saved task or a schedule then keeps covering the right days instead of going empty once the dates pass.

## `dateTo` (type: `string`):

Set both dates or neither. Eventbrite ignores one-sided ranges, so a missing boundary is filled in automatically and reported in the log. Use YYYY-MM-DD. You can also give a moving date instead of a fixed one: today, tomorrow, yesterday, or a day offset such as +30 or -7. A saved task or a schedule then keeps covering the right days instead of going empty once the dates pass.

## `maxItems` (type: `integer`):

Stop after this many events. Keeps the cost of a run predictable.

## `includeDetails` (type: `boolean`):

Opens the page of every event and adds the organizer name, the lowest and highest ticket price with currency, ticket availability (sold out or not) and the event status. One extra request per event, which adds up to a second per event to the run. The price per event stays the same. Organizer contact details and attendee data are never collected.

## Actor input object example

```json
{
  "place": "united-states--new-york",
  "price": "all",
  "maxItems": 50,
  "includeDetails": false
}
```

# Actor output Schema

## `events` (type: `string`):

Every event found, deduplicated by event ID.

## `coverage` (type: `string`):

What the run reached and what it could not. Lists any slice that stayed capped after subdivision, so you can see the limits of the result instead of guessing.

# 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 = {
    "place": "united-states--new-york",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("deriverge/eventbrite-scraper").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 = {
    "place": "united-states--new-york",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("deriverge/eventbrite-scraper").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 '{
  "place": "united-states--new-york",
  "maxItems": 50
}' |
apify call deriverge/eventbrite-scraper --silent --output-dataset

```

## MCP server setup

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

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/fFANkIkOxbIsQrkK1/builds/pfNM2dYwanybWOdfx/openapi.json
