# Eventbrite Scraper - Events, Tickets & Organizers (`bujhmml/eventbrite-scraper`) Actor

Scrape Eventbrite events by city, keyword, category or URL. Get names, dates, venue address with lat/long, online flag, organizer, category, ticket price range, free/paid flag, availability, image and description. HTTP-first, no browser.

- **URL**: https://apify.com/bujhmml/eventbrite-scraper.md
- **Developed by:** [Ihor Bielievskiy](https://apify.com/bujhmml) (community)
- **Categories:** Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.40 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Eventbrite Scraper - Events, Tickets & Organizers

Pull structured event data from [Eventbrite](https://www.eventbrite.com) by city, keyword, category, or by pasting URLs. For every event you get the name, exact start/end times, the venue with full address and coordinates, whether it is online or in person, the organizer, the Eventbrite category, the ticket price range with a free/paid flag, availability, the cover image, and the description.

No headless browser. Eventbrite's search and browse pages embed their full result set as inline JSON, and each event page exposes structured `schema.org` data, so the actor reads those directly. Requests use a real Chrome TLS fingerprint (via `curl_cffi`), which keeps it fast and cheap, and datacenter proxies are enough.

### What you can scrape

- All upcoming events in any city Eventbrite covers, or online-only events.
- Keyword searches (e.g. `jazz`, `startup`, `yoga`) scoped to a location.
- A whole Eventbrite category (Music, Business, Food & Drink, and 18 more).
- Any Eventbrite search, browse, or individual event URL you paste in.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `location` | string | City, region, or country, e.g. `New York`, `San Francisco`, `London`, `United States`. Free text is resolved to Eventbrite's location. Use `online` for online-only events. |
| `query` | string | Optional keyword filter, combined with the location. Ignored when a category is selected. |
| `category` | string | Optional Eventbrite category (`music`, `business`, `food-and-drink`, `arts`, ...). Takes precedence over the keyword and date filters. |
| `dateFilter` | string | Optional relative window for keyword/location searches: `today`, `tomorrow`, `this-week`, `this-weekend`, `this-month`, `next-week`, `next-month`. |
| `startUrls` | array | Eventbrite search/browse URLs (`/d/...`, `/b/...`) or individual event URLs (`/e/...`). Used in addition to the location search. |
| `maxItems` | integer | Stop after this many events across all sources. `0` = no limit. Default `100`. |
| `scrapeEventDetails` | boolean | Fetch each event page to add ticket price, free/paid flag, availability, organizer name/URL, and exact times. Turn off for a faster, cheaper run with listing-level fields only. Default `true`. |
| `proxyConfiguration` | object | Apify Proxy. Datacenter is enough; switch to residential only if you start seeing blocks. |
| `impersonate` | string | curl_cffi browser fingerprint: `chrome` (default), `chrome131`, `chrome124`, `safari17_0`. |

Provide at least one of `location`, `query`, `category`, or `startUrls`. Pagination is automatic - the actor walks the result pages until the location runs out of events or `maxItems` is reached.

Example input:

```json
{
  "location": "New York",
  "query": "live music",
  "dateFilter": "this-weekend",
  "maxItems": 200,
  "scrapeEventDetails": true
}
````

### Output

One dataset item per event:

```json
{
  "id": "1989784917251",
  "name": "PrideFest 2026: FREE RSVP",
  "url": "https://www.eventbrite.com/e/pridefest-2026-free-rsvp-registration-1989784917251",
  "summary": "RSVP here for our free street festival on 4th Avenue from Astor Place to 14th Street!",
  "description": "RSVP here for our free street festival, taking place Sunday, June 28th...",
  "start_datetime": "2026-06-28T11:00:00-04:00",
  "end_datetime": "2026-06-28T18:00:00-04:00",
  "timezone": "America/New_York",
  "is_online": false,
  "venue_name": "PrideFest",
  "venue_address": "4th Avenue between Union Square and Astor Place, Manhattan, NY 10003",
  "venue_city": "Manhattan",
  "venue_region": "NY",
  "venue_postal_code": "10003",
  "venue_country": "US",
  "latitude": 40.7333524,
  "longitude": -73.9902571,
  "organizer_id": "7937981614",
  "organizer_name": "NYC Pride",
  "organizer_url": "https://www.eventbrite.com/o/nyc-pride-7937981614",
  "category": "Community & Culture",
  "subcategory": "LGBT",
  "format": "Festival or Fair",
  "price_min": 0.0,
  "price_max": 0.0,
  "currency": "USD",
  "is_free": true,
  "availability": "InStock",
  "status": "EventScheduled",
  "is_cancelled": null,
  "image_url": "https://img.evbuc.com/...original.20260517-173925?...",
  "tickets_url": "https://www.eventbrite.com/checkout-external?eid=1989784917251",
  "is_series": false,
  "series_id": null
}
```

Field notes:

- `start_datetime`/`end_datetime` carry the venue's UTC offset when `scrapeEventDetails` is on. With detail scraping off they fall back to the local date and time without an offset, alongside the `timezone` name.
- `price_min`/`price_max`/`currency`/`is_free`/`availability`, `organizer_name`/`organizer_url`, and `status` come from the event page and are populated only when `scrapeEventDetails` is on.
- `category`/`subcategory`/`format` are Eventbrite's own labels. `latitude`/`longitude` come from the venue when Eventbrite publishes them.
- `is_series` is true when the event is one occurrence of a recurring series (`series_id` is set).
- Events are deduplicated by `id` across every source.

Unresolvable inputs and fetch/parse failures are written as typed error items (`{ "error": ..., "source_url": ..., "detail": ... }`) so one bad URL or a markup change never silently empties your run. The `error` field is one of `unsupported_url`, `not_found` (dead URL), `blocked` (anti-bot challenge), `fetch_failed` (transient network or HTTP error), or `parse_failed` (an event did not match the expected shape). If every source fails and zero events are scraped, the run is marked **FAILED** with a status message instead of reporting a green, empty success, so schedulers and monitors are not deceived.

### Billing

Pay-per-result: one `event` charge event per stored event. Error records are never charged.

### Notes

- Event lists live in the page's `window.__SERVER_DATA__` blob; ticket and organizer details come from each event page's `schema.org` JSON-LD. If Eventbrite changes either structure, the actor emits an explicit error rather than empty results.
- Network calls have a 30s timeout and bounded retries with exponential backoff and jitter; `403`/`429` are treated as blocks and retried. Concurrency is bounded.

# Actor input Schema

## `location` (type: `string`):

City, region or country to search, e.g. New York, San Francisco, London, or United States. Free text is resolved to Eventbrite's location; use online to scrape online-only events.

## `query` (type: `string`):

Optional keyword filter, e.g. jazz, startup, yoga. Combined with the location above. Ignored when a Category is selected.

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

Optional Eventbrite category to browse instead of a keyword search. When set, it takes precedence over the keyword and date filters.

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

Optional relative date window for keyword/location searches. Eventbrite already excludes past events.

## `startUrls` (type: `array`):

Paste Eventbrite search/browse URLs (e.g. https://www.eventbrite.com/d/ny--new-york/all-events/) or individual event URLs (https://www.eventbrite.com/e/...). Used in addition to the location search above.

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

Stop after this many events across all sources. 0 = no limit.

## `scrapeEventDetails` (type: `boolean`):

Fetch each event page to enrich results with ticket price range, free/paid flag, availability, organizer name/URL and exact start/end times. Turn off for a faster, cheaper run that returns listing-level fields only.

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

Apify Proxy. Eventbrite serves clean responses from datacenter IPs, so the default is enough; switch to residential only if you start seeing blocks.

## `impersonate` (type: `string`):

curl\_cffi impersonation target used for requests.

## Actor input object example

```json
{
  "location": "New York",
  "category": "",
  "dateFilter": "",
  "maxItems": 100,
  "scrapeEventDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "impersonate": "chrome"
}
```

# 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 = {
    "location": "New York",
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("bujhmml/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 = {
    "location": "New York",
    "maxItems": 100,
}

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

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

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

```

## CLI example

```bash
echo '{
  "location": "New York",
  "maxItems": 100
}' |
apify call bujhmml/eventbrite-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=bujhmml/eventbrite-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eventbrite Scraper - Events, Tickets & Organizers",
        "description": "Scrape Eventbrite events by city, keyword, category or URL. Get names, dates, venue address with lat/long, online flag, organizer, category, ticket price range, free/paid flag, availability, image and description. HTTP-first, no browser.",
        "version": "0.1",
        "x-build-id": "znumHfJNjLkr5Esoa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bujhmml~eventbrite-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bujhmml-eventbrite-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/bujhmml~eventbrite-scraper/runs": {
            "post": {
                "operationId": "runs-sync-bujhmml-eventbrite-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/bujhmml~eventbrite-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-bujhmml-eventbrite-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "location": {
                        "title": "Location / city",
                        "type": "string",
                        "description": "City, region or country to search, e.g. New York, San Francisco, London, or United States. Free text is resolved to Eventbrite's location; use online to scrape online-only events."
                    },
                    "query": {
                        "title": "Search keywords",
                        "type": "string",
                        "description": "Optional keyword filter, e.g. jazz, startup, yoga. Combined with the location above. Ignored when a Category is selected."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "music",
                            "business",
                            "food-and-drink",
                            "community",
                            "arts",
                            "film-and-media",
                            "sports-and-fitness",
                            "health",
                            "science-and-tech",
                            "travel-and-outdoor",
                            "charity-and-causes",
                            "spirituality",
                            "family-and-education",
                            "holiday",
                            "government",
                            "fashion",
                            "home-and-lifestyle",
                            "auto-boat-and-air",
                            "hobbies",
                            "school-activities",
                            "other"
                        ],
                        "type": "string",
                        "description": "Optional Eventbrite category to browse instead of a keyword search. When set, it takes precedence over the keyword and date filters.",
                        "default": ""
                    },
                    "dateFilter": {
                        "title": "Date filter",
                        "enum": [
                            "",
                            "today",
                            "tomorrow",
                            "this-week",
                            "this-weekend",
                            "this-month",
                            "next-week",
                            "next-month"
                        ],
                        "type": "string",
                        "description": "Optional relative date window for keyword/location searches. Eventbrite already excludes past events.",
                        "default": ""
                    },
                    "startUrls": {
                        "title": "Eventbrite URLs",
                        "type": "array",
                        "description": "Paste Eventbrite search/browse URLs (e.g. https://www.eventbrite.com/d/ny--new-york/all-events/) or individual event URLs (https://www.eventbrite.com/e/...). Used in addition to the location search above.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max events",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many events across all sources. 0 = no limit.",
                        "default": 100
                    },
                    "scrapeEventDetails": {
                        "title": "Scrape ticket price & organizer",
                        "type": "boolean",
                        "description": "Fetch each event page to enrich results with ticket price range, free/paid flag, availability, organizer name/URL and exact start/end times. Turn off for a faster, cheaper run that returns listing-level fields only.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Apify Proxy. Eventbrite serves clean responses from datacenter IPs, so the default is enough; switch to residential only if you start seeing blocks.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "impersonate": {
                        "title": "Browser TLS fingerprint",
                        "enum": [
                            "chrome",
                            "chrome131",
                            "chrome124",
                            "safari17_0"
                        ],
                        "type": "string",
                        "description": "curl_cffi impersonation target used for requests.",
                        "default": "chrome"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
