# Eventbrite Events Scraper: Search by City, Category & Date (`fairfetch/eventbrite-events-scraper`) Actor

Search Eventbrite events by city or online, keyword, category, event type, date range and free/paid, or read event URLs. One clean row per event: start/end with time zone, venue with coordinates, organizer, ticket price range, sales status, optional full description. $1 per 1,000 events.

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

## Pricing

from $1.00 / 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 Events Scraper: Search by City, Category & Date

Get **Eventbrite events for any city (or online) as clean JSON**: search by location, keyword, category, event type, date (today, this weekend, a date range) and free or paid, or paste Eventbrite search URLs and event URLs. Every row has the start and end time with time zone, the venue with address and coordinates, the organizer, the **ticket price range**, the sales status (on sale, sold out, sales ended) and a link to the event. Turn on page details for the full description, refund policy, age limit and organizer stats. Built for people and AI agents: pay per event, no usage fees and no start fee beyond Apify's standard $0.00005 per run.

| What you pay for | Price |
|---|---|
| `event`: one event from a search (all fields except the page details) | **$0.001** ($1 per 1,000 events) |
| `event-details`: one event with its event page read (full description, refund policy, organizer stats...) | **$0.002** ($2 per 1,000 events) |
| Actor start (standard Apify event, per run) | $0.00005 |

| Example | Rows | Cost |
|---|---|---|
| The prefilled input: 10 events in New York | 10 events | **$0.01** |
| All music events in London this weekend (up to 1,000) | 1,000 events | $1.00 |
| The same with full descriptions | 1,000 events with details | $2.00 |
| Lead list: business + tech conferences and networking events in San Francisco, Berlin, Sydney and online (our test run) | 1,320 events | $1.32 |
| 100 event pages from a list of URLs | 100 events with details | $0.20 |

Apify platform costs (including proxies when needed) are included. Locations that can't be found, events that no longer exist, invalid inputs and the run summary are free. Set **Maximum cost per run** (or `maxTotalChargeUsd` in the API) and the Actor stops cleanly at that amount; it never downloads events it can't charge for.

### What you get

- **Search like on eventbrite.com**: any city, region or country Eventbrite knows (`London`, `Austin, TX`, `Paris, France`, `Germany`), Eventbrite place slugs (`ny--new-york`) or `online`, combined with keywords, the 21 Eventbrite categories, 20 event types (conference, workshop, networking, festival, concert...), date filters and free / paid.
- **One flat row per event** with the same fields for every source: `eventId`, `url`, `name`, `summary`, `startDate` / `endDate` (ISO 8601 with the event's UTC offset, e.g. `2026-11-04T10:00:00-08:00`), `startDateUtc` / `endDateUtc`, `timezone`, `durationMinutes`, `isOnline`, venue name, one-line address, city, region, postal code, country code, latitude / longitude, organizer name, profile URL, ID and followers, category, subcategory, event type, organizer tags, `isFree`, `minPrice` / `maxPrice` / `currency`, `ticketsUrl`, `imageUrl`, `salesStatus`, `isSoldOut`, `isCancelled`, language, series ID for recurring events, publish date.
- **Event page details (optional)**: full description as plain text, event status (live, started, ended, canceled), refund policy, age restriction, duration, verified-organizer flag and the organizer's number of events.
- **Event URLs**: read single events from any Eventbrite country site (`eventbrite.com`, `.co.uk`, `.com.au`, `.de`...) or by event ID.
- **Each event once per run**: an event found by several searches is returned and charged once.
- **Fast and light**: the Actor uses the same search data the Eventbrite website loads (50 events per request), so 1,000 events take about a minute, and several searches run in parallel.
- **No attendee data, no contact details**: the Actor never reads attendees or ticket buyers and drops the organizer contact fields Eventbrite offers (website, Facebook, Twitter). Contact details that organizers type into free text (name, summary, description, organizer and venue name) are removed, best effort: e-mail addresses, phone numbers, social-media links and @handles become `[email removed]`, `[phone removed]`, `[social link removed]` and `[handle removed]`. Dates, times, prices, postcodes and links to Eventbrite pages stay. The organizer is returned as its public Eventbrite profile name and link.
- Built for automation and AI agents: pay-per-event pricing without usage fees, limited permissions, a stable schema, a machine-readable `SUMMARY` record per run and clear per-input errors instead of failed runs.

### Use cases

- **Event discovery and listings**: fill a city guide, newsletter, community calendar or "things to do" app with upcoming events, prices and images.
- **Lead generation and sales prospecting**: find conferences, trade shows and networking events in your industry and cities, with their organizers' Eventbrite profiles and follower counts.
- **Market and pricing research**: compare ticket prices, free vs paid share, sold-out events and categories across cities and dates.
- **Venue and sponsorship research**: which venues host which kinds of events, how often, at what price points.
- **Monitoring**: schedule a weekly run of "this weekend" or "next week" for your cities and categories and get new events automatically.
- **AI agents**: one tool for "What tech meetups are in Berlin next week?", "Find free yoga classes in Chicago in November" or "Which business conferences in Sydney still have tickets?", with structured answers.

### How to use

1. **Locations**: one per line. A city or place name (`London`, `Austin, TX`, `Paris, France`), an Eventbrite place slug from a search URL (`ny--new-york`, `united-kingdom--london`) or `online`.
2. Optional **Keywords**, **Categories** and **Event types**. Every combination is a separate search (2 locations x 2 categories = 4 searches).
3. Optional filters: **When** (today, tomorrow, this weekend, this week, next week, this month, next month) or a **From / To date** range, and **Price** (free or paid).
4. **Max events per search** (default 100, Eventbrite's own limit is 1,000) and, if you like, **Max events in total**.
5. Turn on **Include event page details** for full descriptions and the other page-only fields.
6. Or paste **Eventbrite search URLs** (filters are read from the URL) and **Event URLs**.
7. Run it and download the results as JSON, CSV or Excel, or read them via API. The dataset has the views **Events**, **Venues & organizers**, **Details** and **All fields**.

#### Input examples

The prefilled input:

```json
{
  "locations": ["New York"],
  "maxEventsPerSearch": 10
}
```

Business and tech conferences and networking events in three cities and online (our larger test run):

```json
{
  "locations": ["San Francisco", "Berlin, Germany", "Sydney", "online"],
  "categories": ["business", "science-and-tech"],
  "eventTypes": ["conference", "networking"],
  "maxEventsPerSearch": 200
}
```

Free yoga in Chicago between two dates, with full descriptions, plus a browser search URL and an event page:

```json
{
  "locations": ["Chicago"],
  "keywords": ["yoga"],
  "startDate": "2026-10-25",
  "endDate": "2026-11-15",
  "priceFilter": "free",
  "includeDetails": true,
  "searchUrls": ["https://www.eventbrite.co.uk/d/united-kingdom--london/music--events--this-weekend/"],
  "eventUrls": ["https://www.eventbrite.com/e/nightfall-tickets-1994224684715"]
}
```

More: `"dateFilter": "this_weekend"`, `"priceFilter": "paid"`, `"maxEvents": 500`, `"locations": ["united-kingdom"]` (a whole country), `"eventTypes": ["class", "festival"]`.

#### Output example

A complete search row (every row has these 55 keys; `null` when Eventbrite doesn't say) from our test run on 18 Oct 2026 (San Francisco, Science & Technology, Conference):

```json
{
  "eventId": "1970664169580",
  "url": "https://www.eventbrite.com/e/the-14th-structural-proteomics-symposium-tickets-1970664169580",
  "name": "The 14th Structural Proteomics Symposium",
  "summary": "Join us at QBI UCSF for the 14th Symposium on Structural Proteomics—making its West Coast debut!",
  "description": null,
  "startDate": "2026-11-04T10:00:00-08:00",
  "endDate": "2026-11-06T18:00:00-08:00",
  "startDateUtc": "2026-11-04T18:00:00Z",
  "endDateUtc": "2026-11-07T02:00:00Z",
  "timezone": "America/Los_Angeles",
  "durationMinutes": 3360,
  "isOnline": false,
  "venueName": "UCSF Mission Bay",
  "venueAddress": "1700 4th Street, San Francisco, CA 94158",
  "venueCity": "San Francisco",
  "venueRegion": "CA",
  "venuePostalCode": "94158",
  "venueCountry": "US",
  "latitude": 37.7669687,
  "longitude": -122.3937191,
  "organizerName": "QBI",
  "organizerUrl": "https://www.eventbrite.com/o/qbi-17597117558",
  "organizerId": "17597117558",
  "organizerFollowers": 745,
  "organizerVerified": null,
  "organizerEventCount": null,
  "category": "Science & Technology",
  "subcategory": "Science",
  "format": "Conference",
  "tags": ["Symposium", "Researchers", "Biomolecular", "14th_event", "structural_proteomics"],
  "isFree": false,
  "minPrice": 157.34,
  "maxPrice": 520.29,
  "currency": "USD",
  "ticketsUrl": "https://www.eventbrite.com/checkout-external?eid=1970664169580",
  "imageUrl": "https://img.evbuc.com/https%3A%2F%2Fcdn.evbuc.com%2Fimages%2F1170993356%2F...",
  "salesStatus": "on_sale",
  "isSoldOut": false,
  "isCancelled": false,
  "status": null,
  "refundPolicy": null,
  "ageRestriction": null,
  "language": "en-us",
  "seriesId": null,
  "publishedAt": "2025-11-17T19:14:20Z",
  "createdAt": null,
  "detailsIncluded": false,
  "source": "search",
  "searchInput": "San Francisco",
  "searchLocation": "San Francisco, California, United States",
  "searchKeyword": null,
  "searchCategory": "Science & Technology",
  "searchFormat": "Conference",
  "position": 1,
  "scrapedAt": "2026-10-18T05:01:20Z"
}
```

With **Include event page details** the same row also has (from the Chicago yoga run, description shortened):

```json
{
  "description": "This beginner-friendly yoga series features a heart-centered, healing slow flow practice ...",
  "status": "live",
  "durationMinutes": 75,
  "refundPolicy": null,
  "ageRestriction": null,
  "organizerVerified": false,
  "organizerEventCount": 604,
  "createdAt": "2026-09-10T21:24:30Z",
  "detailsIncluded": true
}
```

#### Output fields

| Field | Description |
|---|---|
| `eventId`, `url`, `name`, `summary` | Eventbrite event ID, event page (tracking parameters removed), name, short summary |
| `description` | Full description as plain text (event page details only) |
| `startDate`, `endDate`, `timezone` | Local start / end with UTC offset (ISO 8601) and the IANA time zone |
| `startDateUtc`, `endDateUtc`, `durationMinutes` | The same in UTC; duration in minutes |
| `isOnline` | Online event (venue fields are then empty) |
| `venueName`, `venueAddress`, `venueCity`, `venueRegion`, `venuePostalCode`, `venueCountry`, `latitude`, `longitude` | Venue; country as ISO code |
| `organizerName`, `organizerUrl`, `organizerId`, `organizerFollowers` | Organizer's public Eventbrite profile |
| `organizerVerified`, `organizerEventCount` | Verified organizer, events hosted on Eventbrite (event page details only) |
| `category`, `subcategory`, `format`, `tags` | Eventbrite category, subcategory, event type, organizer's tags |
| `isFree`, `minPrice`, `maxPrice`, `currency` | Free flag, cheapest and most expensive ticket (e.g. `25.5`), ISO currency |
| `ticketsUrl`, `imageUrl` | Where tickets are sold, event image |
| `salesStatus`, `isSoldOut`, `isCancelled` | `on_sale`, `sold_out`, `sales_ended`, `not_yet_on_sale`, `unavailable`... |
| `status`, `refundPolicy`, `ageRestriction`, `createdAt` | Event status, refund policy (`no_refunds`, `custom`, `flexible`...), age limit (`18+`), creation date (event page details only) |
| `language`, `seriesId`, `publishedAt` | Event language, series ID of recurring events, publish date (search rows) |
| `detailsIncluded`, `source` | Event page read (charged as `event-details`); `search` or `event_url` |
| `searchInput`, `searchLocation`, `searchKeyword`, `searchCategory`, `searchFormat`, `position`, `scrapedAt` | Which input found the event, the resolved place, the search filters, rank in the results, run time |

### Use it from the API, an app or an AI agent

Run synchronously and get the rows in one call (keep your API token in the `APIFY_TOKEN` environment variable):

```bash
curl -X POST "https://api.apify.com/v2/acts/fairfetch~eventbrite-events-scraper/run-sync-get-dataset-items?maxTotalChargeUsd=0.50" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"locations": ["Austin, TX"], "categories": ["music"], "dateFilter": "this_weekend", "maxEventsPerSearch": 200}'
```

Python (`pip install apify-client`):

```python
import os
from decimal import Decimal

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("fairfetch/eventbrite-events-scraper").call(
    run_input={"locations": ["London"], "keywords": ["python"], "dateFilter": "next_month", "maxEventsPerSearch": 100},
    max_total_charge_usd=Decimal("0.20"),
)
for row in client.dataset(run.default_dataset_id).iterate_items():
    print(row["startDate"], row["name"], row["venueName"], row["minPrice"], row["currency"], row["url"])
```

The Actor runs with limited permissions and pay-per-event pricing without usage fees, so AI agents can call it through the Apify MCP server and pay per run. Each run also writes a `SUMMARY` record (per-input counts, errors, notes and request statistics) to its key-value store.

### Performance and limits

- From our test runs on Apify (256 MB, 18-19 Oct 2026): the prefilled input took about 6 seconds; 1,320 events from 16 searches about 43 seconds; 150 events with page details about 66 seconds (one page per event). Peak memory stayed under 90 MB.
- **Throughput and run timeout**: searches return about 25-35 events per second with the default 3 searches in parallel (roughly 100,000 per hour); with page details it is about 2.3 events per second (**about 8,000 events per hour**), because every event page is one request and requests are spaced out. Apify's default run timeout is one hour: raise it in the run options for bigger detail runs. Shortly before the timeout (a quarter of it, between 12 and 45 seconds) the Actor stops cleanly, keeps everything it returned and says so in the status message and in the notes of each search it cut short (events whose page was still queued come without page details and are charged as `event`); the `SUMMARY` record is also updated during the run.
- **Moved runs continue**: if Apify moves a run to another server, it continues where it stopped, without returning or charging any event twice.
- When several searches run in parallel, they share "Max events in total" and your maximum cost per run: a search waits for budget that other searches reserved but didn't use, instead of stopping early.
- **Eventbrite returns at most 1,000 events per search.** For bigger cities, split by category, event type or date range; the run summary tells you when a search hit the limit.
- Eventbrite collapses recurring events in search results to one date per series (like its website); `seriesId` links them.
- Small towns include nearby events (Eventbrite widens the area); filter on `venueCity` if you need the town only.
- Event pages of ended or deleted events can answer "not found"; with page details on, those rows keep their search data and are charged as `event`.
- Requests are polite (at most about 3 per second, retries with backoff). In all our tests Eventbrite answered Apify's servers directly; if it ever shows its "Human Verification" page, the run switches to Apify residential proxies in the searched place's country automatically (included in the price). CAPTCHAs are never solved.
- Rows from event URLs have no organizer tags or follower count (event pages don't show them); search rows have no full description unless page details are on.
- Locations are place names, slugs or Eventbrite place IDs. **ZIP and postal codes aren't supported** (Eventbrite's place search doesn't know them): such inputs are reported as `invalid_input` and cost nothing. Date ranges that end in the past are rejected the same way (Eventbrite lists upcoming events only; "past" means before today in the last time zone on Earth, so today's date always works).
- Ambiguous names pick the place with the most upcoming events and say so in the notes of the run summary (`SUMMARY`), e.g. "Dublin" is Dublin, Ireland, "Springfield" is Springfield, Missouri, and "Washington" is Washington State; type "Dublin, CA", "Washington, DC", "Springfield, IL" or a slug for another. A US place wins only a near tie (up to about 1.4 times its events: "Cambridge" is Cambridge, MA). Big cities such as London or New York don't get this note.
- Eventbrite's place search knows many cities only by their local name. 48 cities are built in under their English and ASCII names and checked against the live place search: "Munich" is München, "Vienna" Wien, "Rome" Roma, "Prague" Praha, "Sao Paulo" São Paulo, "Frankfurt" Frankfurt am Main, "Brisbane" Brisbane City, "Charlotte" Charlotte, NC, and others. Accents and case don't matter, and common accented city names are also searched with their accents ("Cordoba" as "Córdoba", "Cancun" as "Cancún"). A same-named town is still yours with its state or country ("Vienna, VA", "Rome, GA", "Naples, FL"), and the run summary names it when it has a share of the events. For a city not in the list, type its local name ("Göteborg") or use a slug. Eventbrite's place search doesn't return every US state ("Georgia" is the country): a place with no upcoming events gets a hint to type a city such as "Atlanta, GA".
- Search URLs are read like the website does: `/d/<place>/parties/`, `/conferences/`, `/classes/` and the other event-type words are filters, `/d/<place>/music--events/` is a category, and a single other word (`/d/<place>/music/`, `/party/`) is a keyword search. `/b/<place>/<category>/` browse pages are categories.

### FAQ

**Do I need an Eventbrite account or API key?**
No. The Actor reads the public event listings every visitor of eventbrite.com sees. It doesn't log in and doesn't use Eventbrite's developer API.

**How do I search a whole country or region?**
Type its name (`Germany`, `united-kingdom`, `California`) as a location. Eventbrite's 1,000-results-per-search limit still applies, so add categories or date ranges for more.

**The wrong city was found. What can I do?**
Add the region or country (`London, Canada`, `Paris, TX`, `Washington, DC`; the comma is optional: `Vienna VA`, `Munich Germany`) or use the slug from an Eventbrite search URL (`canada--london`). A US state or a country you add must match: if Eventbrite's place search has no such place ("Paris, KY" is tried as "Paris Kentucky" too), the location is reported as `location_not_found` (free) instead of using a place elsewhere. Codes can mean several places: US states, US territories (`PR`), Australian states (`NSW`, `WA`, `SA`, `NT`...), Canadian provinces (`ON`, `BC`, `SK`, `NL`, `PE`...) and country codes (`IE`, `IN`). Each meaning is tried in that order, US states first (also written out, e.g. "Ontario California"), and the first one with a matching place that has upcoming events is used: `Richmond, CA` and `Ontario, CA` are California, `Perth, WA` Western Australia, `Saskatoon, SK` Saskatchewan, `Hyderabad, IN` India. When a later meaning is used, the run summary says so ("Read "WA" as Western Australia"). The place's own name never counts as the qualifier (`Panama City, Panama` isn't Panama City, Florida). The run summary shows which place each location was matched to and lists other places with the same name.

**Why do some events have no price?**
Events with donation tickets, external ticketing or tickets that aren't on sale yet have no price range on Eventbrite. `isFree` is true when Eventbrite marks the event free or every ticket costs 0.

**What happens with wrong inputs?**
The other inputs still run. Each failed input is listed in the status message and in the `SUMMARY` record with the reason (`location_not_found`, `not_found`, `invalid_input`, `blocked`...) and isn't charged. A run whose inputs are all wrong (unknown places, deleted events, ZIP codes, invalid URLs) still finishes as succeeded, with the reasons in the status message; the run fails only when something went wrong on our side (for example Eventbrite blocked every request).

**Does it collect personal data?**
It returns public event listings and the organizer's public Eventbrite profile name and link. It never reads attendees or ticket buyers. E-mail addresses, phone numbers, social-media links and @handles that organizers type into names and descriptions are removed (best effort: an unusual format can slip through, and an "@Venue" written into an event name is kept). When an organizer or event name contained such details, its Eventbrite link is returned in the short ID form (`https://www.eventbrite.com/o/<id>`) so the details don't reappear in the URL.

**How fresh is the data?**
Everything is read live in every run. Schedule the Actor (e.g. daily or weekly) to track new events, price changes and sell-outs.

### Legal

This Actor reads only public event information that Eventbrite shows to every visitor, at a polite request rate. It does not log in, does not solve CAPTCHAs or bypass access controls, does not collect attendee data, and removes contact details typed into event texts (best effort). Eventbrite's terms of service restrict automated access and commercial use of its content: you are responsible for how you use the data and for complying with Eventbrite's terms and the laws that apply to you. When you publish events, link to the event page on Eventbrite. This Actor is not affiliated with, endorsed or sponsored by Eventbrite; "Eventbrite" is a trademark of its owner and is used here only to describe where the data comes from.

# Actor input Schema

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

Where to search, one per line. Accepted forms:

- City or place name: London, Austin, TX, Paris, France, Berlin. A US state or a country after the name must match ("Paris, KY" never gives Paris, France); a code can mean several places (WA: Washington or Western Australia; SK: Saskatchewan or Slovakia), so each is tried, US states first, and the first with a matching place that has events is used ("Richmond, CA" is California, "Perth, WA" Western Australia). English names of big cities work (Munich, Vienna, Rome).
- Eventbrite place slug (from a search URL): ny--new-york, united-kingdom--london, ca--san-francisco
- online (online events only)
- An Eventbrite place ID (number)
  Each location is searched once for every combination of keyword, category and event type below. Eventbrite includes nearby events for small towns.

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

Search words, one search per line, e.g. "python", "yoga", "startup pitch". Leave empty for all events of the location. Eventbrite's keyword search is broad (it also matches descriptions and tags).

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

Eventbrite categories. Each selected category is a separate search; leave empty for all categories.

## `eventTypes` (type: `array`):

Eventbrite event formats, e.g. conferences or workshops. Each selected type is a separate search (combined with the categories above); leave empty for all types.

## `dateFilter` (type: `string`):

Eventbrite's date filter, in each location's own time zone. Ignored when a start or end date is set below.

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

Only events on or after this date, YYYY-MM-DD (e.g. 2026-11-01). Without an end date the range is one year.

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

Only events on or before this date, YYYY-MM-DD. Without a start date the range starts today. Multi-day events that overlap the range are included.

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

Free events only, paid events only, or both.

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

Maximum events returned for each search (each location / keyword / category / event type combination, and each search URL). Eventbrite itself stops at 1,000 events per search; split big cities by date range or category for more.

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

Stop the whole run after this many events. 0 = no limit (the maximum cost per run you set when starting the run also stops it cleanly).

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

Also open each event's page for the full description (plain text), refund policy, age restriction, event status and organizer stats. One extra request per event and charged as "event with details". Rows from event URLs always include details.

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

Search pages copied from your browser, e.g. https://www.eventbrite.com/d/ny--new-york/free--music--events--this-weekend/ or https://www.eventbrite.com/d/online/business--conferences/. The location and filters are read from the URL (the filters above don't apply to them).

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

Event pages to read in full, e.g. https://www.eventbrite.com/e/some-event-tickets-1234567890123 (any Eventbrite country domain), or bare event IDs. Each returns one row with details.

## `maxConcurrency` (type: `integer`):

How many searches run at the same time. Requests to Eventbrite are spaced out in any case.

## `requestTimeoutSecs` (type: `integer`):

Timeout for a single HTTP request.

## `maxRetries` (type: `integer`):

Retries for network errors, HTTP 5xx and blocks, with exponential backoff.

## `proxyConfiguration` (type: `object`):

Requests go to Eventbrite directly first. If Eventbrite blocks them (its "Human Verification" page), the run switches to this proxy, in the searched city's country when it is Apify residential (default, included in the price). Turn it off only for local runs.

## `alwaysUseProxy` (type: `boolean`):

Send every request through the proxy from the start, instead of only after Eventbrite blocks a direct request. Slower and uses proxy traffic; only useful if direct requests keep getting blocked.

## Actor input object example

```json
{
  "locations": [
    "New York",
    "united-kingdom--london",
    "online"
  ],
  "keywords": [
    "python",
    "networking"
  ],
  "dateFilter": "any",
  "priceFilter": "any",
  "maxEventsPerSearch": 10,
  "maxEvents": 0,
  "includeDetails": false,
  "maxConcurrency": 3,
  "requestTimeoutSecs": 30,
  "maxRetries": 4,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "alwaysUseProxy": false
}
```

# Actor output Schema

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

All events from this run as JSON: dates with time zone, venue, organizer, ticket prices, sales status.

## `details` (type: `string`):

The same rows in the "Details" view: status, duration, refund policy, organizer stats, description.

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

Per-input counts (events found and returned, duplicates, pages), notes and errors; requests and traffic.

# 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"
    ],
    "maxEventsPerSearch": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fairfetch/eventbrite-events-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 = {
    "locations": ["New York"],
    "maxEventsPerSearch": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("fairfetch/eventbrite-events-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 '{
  "locations": [
    "New York"
  ],
  "maxEventsPerSearch": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call fairfetch/eventbrite-events-scraper --silent --output-dataset

```

## MCP server setup

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