# Eventbrite Scraper — New Event Alerts (`magnova/eventbrite-scraper`) Actor

Search Eventbrite by city, category or keyword — title, start/end with timezone, when the event was listed, venue, category and tags; recurring series as one record. Monitoring mode delivers only newly listed events. $0.01 per event, no start fee.

- **URL**: https://apify.com/magnova/eventbrite-scraper.md
- **Developed by:** [Magnova](https://apify.com/magnova) (community)
- **Categories:** Travel, Automation, Lead generation
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 events

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Scraper — New Event Alerts

**Every event on Eventbrite, as clean structured records — search any city by category or keyword, with a monitoring mode that delivers only what's newly listed.**

Eventbrite lists thousands of new events every day — concerts, conferences, classes, meetups — and the people who watch them (promoters tracking a scene, media building what's-on digests, agents planning weekends, teams watching competitor events) currently pay snapshot scrapers for the same full corpus again and again, just to spot what's new. This Actor reads Eventbrite's public destination pages — the same listings its browse pages show everyone, logged out, with no API key — and turns them into flat, analysis-ready records: title, start and end in the event's own timezone, the moment the event was listed, venue and city, category, format and tags.

It is built scraper-first, with monitoring as a mode: your first run pulls the current corpus for your slice (a city, a category, a keyword), and scheduled runs after that deliver **only the events you haven't seen** — the new-event alerts that snapshot Eventbrite scrapers never offer. One customer pattern on this shelf runs a snapshot actor over 1,200 times a month to fake exactly that delta; here, a quiet check costs nothing.

### Sample output

A real record, as delivered:

```json
{
  "recordType": "EVENT",
  "eventId": "1994434242508",
  "eventTitle": "Friday Night Lights at Mama Taco Everyone FREE B4 12am w/RSVP",
  "eventUrl": "https://www.eventbrite.com/e/friday-night-lights-at-mama-taco-everyone-free-b4-12am-wrsvp-tickets-1994434242508",
  "startDateTime": "2026-11-13T20:00:00",
  "endDateTime": "2026-11-14T05:00:00",
  "startDate": "2026-11-13",
  "timezone": "America/New_York",
  "listedAt": "2026-07-18T17:21:43Z",
  "venueName": "MAMATACO",
  "venueAddress": "880 Flushing Avenue, Brooklyn, NY 11206",
  "city": "Brooklyn",
  "region": "NY",
  "postalCode": "11206",
  "country": "US",
  "isOnline": false,
  "category": "Music",
  "subcategory": "Hip Hop / Rap",
  "eventFormat": "Party or Social Gathering",
  "tags": [
    "Reggae",
    "Afrobeats",
    "Afterwork",
    "Foodanddrink",
    "Libra",
    "Hiphopmusic",
    "Mexicanfood",
    "Happyhourspecials",
    "Tequlia",
    "Birthdaycelebration"
  ],
  "instanceCount": 1,
  "imageUrl": "https://img.evbuc.com/https%3A%2F%2Fcdn.evbuc.com%2Fimages%2F1197478913%2F48251508672%2F1%2Foriginal.20261107-055111?crop=focalpoint&fit=crop&w=512&auto=format%2Ccompress&q=75&sharp=10&fp-x=0.5&fp-y=0.5&s=1a0c7611cb7425891232930246e82ed6",
  "descriptionSnippet": "Get here early, RSVP, and enjoy free entry before midnight for a night full of good vibes and great tacos!",
  "source": "eventbrite"
}
```

### What you get

Each delivered record (`recordType: "EVENT"`, charged) carries:

| Field | What it is |
|---|---|
| `eventId` | The event's stable Eventbrite ID — the dedupe key |
| `eventTitle` | The event title, exactly as listed (on at least 95% of records) |
| `eventUrl` | The event's public page on Eventbrite |
| `startDateTime` / `endDateTime` | Start and end in the event's **local** time (ISO; a bare date when the listing gives no time) — read them with `timezone` |
| `startDate` | The start date alone (ISO date) |
| `timezone` | The event's timezone as listed (e.g. `America/New_York`) (on at least 95% of records) |
| `listedAt` | When the event was listed (published) on Eventbrite, UTC — the field the `listedSince` cursor compares against (on at least 95% of records) |
| `venueName` / `venueAddress` | The venue's name and displayed address — in-person events; online events have no venue |
| `city` / `region` / `postalCode` / `country` | Where the event happens, as listed — from the venue address, so online events (no venue) usually omit them |
| `isOnline` | `true` for online events, `false` for in-person |
| `category` / `subcategory` / `eventFormat` | Eventbrite's own classification as listed (category on at least 90% of records) |
| `tags` | The organiser's public tags for the event |
| `seriesId` / `instanceCount` | When an event is one instance of a recurring series: the series' ID and how many instances the listing counts. A series is delivered **once** — the record shows its next instance |
| `imageUrl` | The event's listing image |
| `descriptionSnippet` | The listing's short description (up to 1,000 characters) (on at least 85% of records) — the full description lives on the event page |

Every run ends with one `SUMMARY` record (never charged): how many events matched, how many were read, delivered, skipped as duplicates, cancelled or filtered out, and whether the run stopped at a cap. If a destination cannot be read, the run writes one `ERROR` record for it plus the summary instead of pretending there were no new events — and in monitoring mode the state is not advanced, so the next run catches up.

**What is never in a record:** ticket prices and organiser contact data. Eventbrite's listing cards don't publish prices (they live on each event's ticket page), and this Actor reads listings, not ticket pages — so no price is invented and none is promised. Organiser names and emails are likewise not part of the listing data and are never shipped; if an email address ever appeared inside a description an organiser typed, it would be stripped before the record ships.

### Use it as an API (Server Actor)

This actor also runs as a **server**: send one HTTP request and get the events back in the response — no run to start, no dataset to poll.

```
POST https://magnova--eventbrite-scraper.apify.actor
Authorization: Bearer <YOUR_APIFY_TOKEN>
Content-Type: application/json

{"cities": ["Austin"], "maxResults": 25}
```

The body takes the same fields as the normal input below. The response is `{"records": [...], "summary": {...}}`. Server mode is a snapshot lookup — the monitor state store stays a scheduled/batch-run feature — and one request returns at most 100 events. You are charged the same $0.01 per delivered event as a normal run (tiered by your Apify plan), billed to your own Apify account; error rows are never charged.

### Three ways to run it

**1. Corpus (default).** A run delivers the matching events for its destinations: pick cities and a category (or paste whole destination URLs), optionally a keyword, a date window and the free/online switches. This is the first-run sale: pull a city's weekend lineup, a category's full upcoming corpus, and analyse it offline.

**2. Monitoring mode.** Select one of your key-value stores in the *Monitor state store* input and schedule the run (hourly or daily suits events — new listings land all day). The first run delivers the current matches as a charged baseline; every later run delivers only events the store hasn't seen. Set *Start monitoring silently* (`monitorOnlyNew`) to skip the baseline: the first run just remembers the current events, and you receive only what appears afterwards. A recurring series is remembered **by its series**, so a weekly club night alerts once — it does not re-alert for every future instance. Events a run couldn't deliver (cap reached, timeout) stay unseen and are delivered by the next run.

**3. Cursor mode.** Hold your own state in Make, Zapier or your scheduler: pass `listedSince` (an ISO date or datetime) and each run delivers events **listed at or after** that moment — stateless incremental, no store needed. The cursor is enforced on every event's own `listedAt`, boundary-inclusive: nothing older is ever delivered or charged. (Destination pages rank by relevance, not listing date, so a cursor run still reads the destination's pages — the cursor filters exactly, it doesn't narrow the read.)

**One source limit, honestly:** a destination page serves at most about 1,000 deduplicated events, however large the destination is (New York music alone matches several thousand). The SUMMARY flags it (`servingCapReached`). Narrower filters, several destinations, or split date windows reach deeper corpora.

### Inputs

| Input | What it does |
|---|---|
| `destinationUrls` | Whole Eventbrite destination (browse) page URLs, used as-is — they carry their own city/category/date facets |
| `cities` | Cities as `"City, Country"` (e.g. `"New York, United States"`), or `"Online"` for the online-events destination |
| `country` | Run-level country for bare city names |
| `category` | Category destination name (`music`, `business`, `food and drink`, …) for the Cities entries |
| `keyword` | Keyword search — Eventbrite's own search with no category; a title/description/tag filter when a category is also set |
| `dateWindow` | `upcoming` (all listed), `today`, `tomorrow`, `this_weekend` (Eventbrite's own facets), or `custom` |
| `dateFrom` / `dateTo` | The custom window (enforced on each event's own start date) |
| `freeOnly` | Browse the free-events destinations (Cities entries) |
| `onlineOnly` | Deliver only online events, on any destination |
| `listedSince` | Stateless cursor: events listed on/after this moment |
| `monitorStore` | Your key-value store for only-new delivery |
| `monitorOnlyNew` | Skip the charged baseline; start silently |
| `maxResults` | Cap on delivered (charged) events per run (prefilled 100, max 5,000) |
| `maxTotalChargeUsd` | Hard stop for the run's charges |

### Pricing

**$0.01 per event delivered** — that's **$10.00 per 1,000 events** (SILVER $0.0085, GOLD+ $0.007), **no start fee**.

**Not charged:** duplicates and already-seen events (including every repeat instance of a series), cancelled events, events filtered out by your window/cursor/switches, silently seeded events (`monitorOnlyNew` first runs), `ERROR` records and the `SUMMARY`. A scheduled monitoring run on a quiet stretch costs nothing.

**Worked example:** watching New York music on an hourly schedule, surfacing roughly 40 newly listed events a day, costs about **$12 a month**. A one-off 1,000-event city corpus pull costs **$10.00** once.

### Examples

Upcoming music events in New York (a typical corpus pull):

```json
{ "cities": ["New York, United States"], "category": "music", "maxResults": 250 }
```

Daily monitoring of London business events, started silently, with your store attached:

```json
{ "cities": ["London, United Kingdom"], "category": "business", "monitorOnlyNew": true, "monitorStore": "<your key-value store>" }
```

Free events in Chicago this weekend:

```json
{ "cities": ["Chicago, United States"], "freeOnly": true, "dateWindow": "this_weekend", "maxResults": 250 }
```

A workflow cursor pull — everything listed since your last run:

```json
{ "cities": ["New York, United States"], "category": "music", "listedSince": "2026-11-09T00:00:00Z", "maxResults": 500 }
```

### Eventbrite API

This Actor is the no-code way to work with Eventbrite's public listings: it handles the destination grammar (cities, categories, date and free facets, the online destination), the pagination up to Eventbrite's per-destination serving window, series collapsing, cross-destination and cross-run dedupe, window and cursor enforcement for you. Compared with snapshot Eventbrite scrapers, you get the same listing data — plus the delta: only-new delivery and a cursor mode the snapshot tools don't offer, at half the per-event price of the shelf's most-used snapshot actor, with no start fee and nothing charged for repeats.

### Use cases

- **What's-on media & newsletters:** a city's new listings as a structured daily feed, ready for a digest.
- **Promoters & venues:** watch your scene — new competing events in your city and category, as they list.
- **Event-led lead timing (events, not contacts):** know the moment a conference or expo in your niche is announced, while tickets and speaking slots are still open.
- **Travel & weekend planning agents:** fresh, dated, venue-complete event corpora for any city, re-pulled on schedule.
- **AI agents:** structured, deduped event data with stable IDs and an explicit listing timestamp, ready for pipelines and RAG — call it via the Apify API or MCP like any other Actor.

### Using this Actor with AI agents (MCP)

The Actor is agent-ready: every input and output field is described, the example input runs as-is, and a single call with the prefill works zero-shot. Typical agent flow: run once with your destinations for the corpus, then schedule runs with a monitor store and consume only the new EVENT records; stop conditions are explicit (`stoppedByMaxCharge`, `stoppedByResultCap`, `streamComplete`, `servingCapReached` in the SUMMARY).

### FAQ

**Does it need an API key or an Eventbrite account?** No. The destination pages are public and logged-out, and the Actor needs no Eventbrite account, login or key — and neither do you.

**Why did my first monitoring run deliver so much?** That's the baseline: the current matches delivered once, so later runs can deliver only what's new. Prefer to start from zero? Turn on *Start monitoring silently*.

**Why no ticket prices?** Eventbrite's listing cards don't carry them — prices live on each event's ticket page, and fetching a page per event would multiply the cost of every record. Rather than invent or estimate prices, the record ships what the listing genuinely publishes. The event page is one click from `eventUrl`.

**Why did a big destination stop around 1,000 events?** That's Eventbrite's per-destination serving window, not this Actor's — the SUMMARY's `servingCapReached` flag tells you when it happened. Split by category or date window to go deeper.

**A weekly series I follow alerted once, then went quiet. Is it broken?** No — that's the series rule working: a series is one watched item. Its record shows the next instance and the total instance count; it won't re-alert for instances you already know about. It will alert again only if the series itself is new to your store.

**How fresh is it?** A run reads the destination pages as they are right now, and `listedAt` tells you exactly when each event appeared on Eventbrite — so a monitoring schedule's cadence is your freshness: hourly runs see new listings within the hour.

### Legal

Eventbrite's event listings are published publicly — titles, dates, venues and categories are facts organisers publish to be discovered. This Actor reads only those public, logged-out destination pages: no login, no API key, no CAPTCHA bypass. Records carry public event and venue facts only — no attendee data and no personal contact data.

# Actor input Schema

## `destinationUrls` (type: `array`):

Eventbrite destination (browse) page URLs to read, exactly as you would paste them from the site — for example "https://www.eventbrite.com/d/united-states--new-york/music/". A URL carries its own city, category, date and price facets with it; the run-level category / keyword / date-window inputs apply to Cities entries, not to URLs. Each URL is one destination; pagination is handled for you.

## `cities` (type: `array`):

Cities to browse, one per entry, written as "City, Country" (e.g. "New York, United States", "London, United Kingdom"). A bare city name uses the run-level Country input. Use "Online" for Eventbrite's online-events destination. The run-level category, keyword, date window and free/online switches apply to every city. Leave empty when you use Destination URLs instead.

## `country` (type: `string`):

Optional run-level country applied to Cities entries written as a bare city name (e.g. city "Austin" + country "United States"). Entries written as "City, Country" carry their own country and ignore this.

## `category` (type: `string`):

Optional Eventbrite category to browse in each city, by its destination name — e.g. "music", "business", "food and drink", "arts", "health", "nightlife", "community", "sports and fitness". It becomes part of the destination page address, so it must be a category Eventbrite itself uses; an unrecognised category makes that destination return an ERROR record instead of guessing. Leave empty to browse all categories.

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

Optional keyword search (e.g. "jazz", "startup mixer"). With no category set, the keyword runs as Eventbrite's own destination search. With a category also set, the category is browsed and the keyword filters the results by title, description and tags. Leave empty for all events in the destination.

## `dateWindow` (type: `string`):

Which events to include by their start date. "upcoming" = everything Eventbrite lists (destination pages show upcoming events only), "today", "tomorrow" and "this_weekend" use Eventbrite's own date facets, and "custom" keeps events starting between Date from and Date to (enforced on each event's own start date; a custom run reads deeper into the destination because the match can sit anywhere in Eventbrite's ranking).

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

Custom window start (ISO date, e.g. "2026-11-14"). Only applies when the date window is "custom"; must be given together with Date to.

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

Custom window end (ISO date, e.g. "2026-11-30"). Only applies when the date window is "custom". Maximum window: 366 days.

## `freeOnly` (type: `boolean`):

On: browse Eventbrite's free-events destinations instead — the free facet is part of the destination address. Applies to Cities entries; destination URLs carry their own facets (use a free-events URL there).

## `onlineOnly` (type: `boolean`):

On: only online events are delivered (in-person events are skipped, never charged). Works for every destination, including URLs. For Eventbrite's dedicated online destination, add "Online" as a city instead — or in addition.

## `listedSince` (type: `string`):

Optional stateless cursor for workflow tools (Make, Zapier, your own scheduler) that hold state themselves: only events LISTED on Eventbrite at or after this moment are delivered — for example "2026-11-01" (a date means the start of that day, UTC) or "2026-11-01T12:00:00Z". The check runs on every event's own listed timestamp (listedAt), boundary-inclusive, so nothing older than the cursor is ever delivered or charged. Destination pages rank by relevance rather than listing date, so a cursor run still reads the destination's pages — it filters, it does not narrow the read. Leave empty for no cursor.

## `monitorOnlyNew` (type: `boolean`):

Off (default): the first run delivers the destinations' current events as a baseline batch (charged), later runs deliver only new ones. On: the first run silently remembers the current events without delivering or charging anything, and only events listed afterwards are ever delivered. Only applies when a monitor store is selected; without a store every run is a baseline run.

## `monitorStore` (type: `string`):

A key-value store this Actor may read and write to remember which events it has already seen — this is what makes only-new delivery work across runs. Pick any store you own; the Actor keeps one small state record in it. A recurring series is remembered by its series, so its next instance does not re-alert. Without a store, every run delivers the destinations' events as a baseline and remembers nothing. If the store is missing or cannot be opened, the run continues in baseline mode and the SUMMARY record says so — it never crashes. The Actor remembers every event it processed (including filtered-out ones), so widening your filters later does not re-deliver old events.

## `maxResults` (type: `integer`):

Hard cap on events delivered (and charged) in one run, across all destinations in the run. Eventbrite serves at most about 1,000 deduplicated events per destination, so several destinations (or narrower filters) reach deeper corpora. Events a capped run could not deliver stay unseen in monitoring mode and are delivered by the next run if they still match.

## `maxTotalChargeUsd` (type: `number`):

Optional hard stop for this run's charges: delivery stops as soon as the charged events reach this amount (checked conservatively at the highest per-event price, so the run may stop slightly early on discounted tiers), and the SUMMARY record reports stoppedByMaxCharge. Undelivered new events stay unseen, so the next run delivers them. Leave empty for no cap. The run-level maximum charge in the run options is also honoured exactly.

## Actor input object example

```json
{
  "destinationUrls": [
    "https://www.eventbrite.com/d/united-states--new-york/music/"
  ],
  "cities": [
    "New York, United States"
  ],
  "country": "United States",
  "category": "music",
  "keyword": "jazz",
  "dateWindow": "upcoming",
  "dateFrom": "2026-11-14",
  "dateTo": "2026-11-30",
  "freeOnly": false,
  "onlineOnly": false,
  "listedSince": "2026-11-01",
  "monitorOnlyNew": false,
  "maxResults": 1000,
  "maxTotalChargeUsd": 1
}
```

# Actor output Schema

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

No description

# 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 = {
    "cities": [
        "New York, United States"
    ],
    "category": "music",
    "dateWindow": "upcoming",
    "freeOnly": false,
    "onlineOnly": false,
    "monitorOnlyNew": false,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("magnova/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 = {
    "cities": ["New York, United States"],
    "category": "music",
    "dateWindow": "upcoming",
    "freeOnly": False,
    "onlineOnly": False,
    "monitorOnlyNew": False,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("magnova/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 '{
  "cities": [
    "New York, United States"
  ],
  "category": "music",
  "dateWindow": "upcoming",
  "freeOnly": false,
  "onlineOnly": false,
  "monitorOnlyNew": false,
  "maxResults": 100
}' |
apify call magnova/eventbrite-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,magnova/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/H9Yqf8dotlmMeMEmG/builds/tEsd7KuGF8QGOySSq/openapi.json
