# Eventbrite Scraper - Events Near Any Location (`sigma-dev/eventbrite-scraper`) Actor

Scrape every Eventbrite event near a latitude/longitude, with optional category and subcategory filters.

- **URL**: https://apify.com/sigma-dev/eventbrite-scraper.md
- **Developed by:** [Sigma Dev](https://apify.com/sigma-dev) (community)
- **Categories:** Automation, Other, Travel
- **Stats:** 2 total users, 1 monthly users, 90.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

Find **every Eventbrite event happening near any point on earth**. Give the Actor a latitude and longitude, optionally pick a category, and it returns the full list of upcoming events with venues, coordinates, dates, ticket prices, and organizers.

### What does Eventbrite Scraper do?

Eventbrite Scraper searches [Eventbrite](https://www.eventbrite.com) by **geographic coordinates** rather than by city name, so you can centre a search anywhere - a neighbourhood, a hotel, a conference venue, a customer's postcode - and get everything happening within a radius you choose. For each event it extracts the name, date and time, full venue address with latitude/longitude, ticket price range, organizer, category, image, and a direct link.

Because it searches by point and radius, you are not limited to the city boundaries Eventbrite's own pages use. A search centred on downtown Brooklyn with a 5 km radius returns exactly that, not "New York".

Running it on Apify means you get scheduled runs, a REST API, webhooks, proxy rotation, monitoring, and one-click integrations with Google Sheets, Slack, Zapier, Make, and more. Just hit **Try for free** above, drop in a latitude and longitude, and click **Start**.

### Why use Eventbrite Scraper?

- **Local event discovery** - power an events feed, newsletter, or app with real listings around your users.
- **Market and competitor research** - see who runs events near a location, how often, and at what price.
- **Venue and hospitality planning** - anticipate demand spikes near a hotel, restaurant, or venue.
- **Lead generation** - build lists of active organizers in a target territory.
- **Sponsorship scouting** - find events by category and size in the regions you care about.
- **Academic and civic research** - measure cultural activity across neighbourhoods.

### How to use Eventbrite Scraper

1. Click **Try for free** and sign in to Apify (a free account is enough to start).
2. Enter the **Latitude** and **Longitude** of the point you want to search around. You can copy these from Google Maps by right-clicking any location.
3. Set the **Search radius**. It defaults to 2 km, which covers a neighbourhood; raise it to 10-25 km for a whole city.
4. Optionally pick a **Category** (like Music or Food & Drink) or a **Subcategory** (like Music > Jazz).
5. Click **Start** and watch the results appear in the **Output** tab.
6. When the run finishes, export your data as JSON, CSV, Excel, HTML, or XML - or pull it from the API.

### Input

All input is configured in the **Input** tab, or passed as JSON via the API. Only `latitude` and `longitude` are required; everything else has a sensible default.

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `latitude` | number | **required** | Latitude of the search centre, in decimal degrees. |
| `longitude` | number | **required** | Longitude of the search centre, in decimal degrees. |
| `radius` | integer | `2` | How far from the centre to search. |
| `radiusUnit` | string | `km` | `km` or `mi`. |
| `category` | string | all | Restrict to one of 21 Eventbrite categories. |
| `subcategory` | string | all | Restrict to a subcategory, shown as `Category > Subcategory`. Overrides `category`. |
| `query` | string | - | Free-text keyword search, e.g. `yoga`. |
| `startDate` | string | today | Only events starting on or after this date (`YYYY-MM-DD`). |
| `endDate` | string | +1 year | Only events starting on or before this date. |
| `priceFilter` | string | `any` | `any`, `free`, or `paid`. |
| `includeOnlineEvents` | boolean | `false` | Keep online events, which have no physical venue. |
| `maxItems` | integer | `50` | Stop after N events. Set to `0` to collect every match with no limit. |
| `scrapeEventDetails` | boolean | `false` | Also fetch each event's full description. Costs one extra request per event. |
| `proxyConfiguration` | object | Apify Proxy | Proxy settings. |

#### Input example

```json
{
    "latitude": 40.7128,
    "longitude": -74.006,
    "radius": 10,
    "radiusUnit": "km",
    "category": "Music",
    "maxItems": 500
}
```

### Output

Every event becomes one dataset record. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
    "id": "1993202951684",
    "name": "CHUG IT Caribbean Festival New York",
    "url": "https://www.eventbrite.com/e/chug-it-caribbean-festival-new-york-tickets-1993202951684",
    "summary": "NEW DATE ALERT!!! Get wild and ready for this LABOR DAY Edition!!",
    "startDate": "2026-09-07",
    "startTime": "15:00",
    "startsAtUtc": "2026-09-07T19:00:00+00:00",
    "timezone": "America/New_York",
    "category": "Food & Drink",
    "subcategory": "Spirits",
    "format": "Festival or Fair",
    "isFree": false,
    "minPrice": 55.2,
    "maxPrice": 55.2,
    "currency": "USD",
    "organizerName": "Opulence Group Inc",
    "venueName": "4106 2nd Ave",
    "venueAddress": "4106 2nd Avenue, Brooklyn, NY 11232",
    "venueCity": "Brooklyn",
    "venueLatitude": 40.6540449,
    "venueLongitude": -74.0121556,
    "distanceKm": 6.554
}
```

#### Data fields

| Field | Description |
| --- | --- |
| `id` | Eventbrite event ID. |
| `name`, `url`, `summary` | Event title, public page URL, and short description. |
| `description`, `descriptionHtml` | Full description, as text and HTML. Only when `scrapeEventDetails` is on. |
| `startDate`, `startTime`, `endDate`, `endTime` | Local start and end, as reported by Eventbrite. |
| `startsAtUtc` | Start time normalised to UTC - use this for sorting across time zones. |
| `timezone` | IANA time zone of the venue. |
| `category`, `subcategory`, `format` | Eventbrite's own taxonomy for the event. |
| `isFree`, `minPrice`, `maxPrice`, `currency` | Ticket pricing. |
| `isSoldOut`, `hasAvailableTickets`, `salesStatus`, `isCancelled` | Availability signals. |
| `ticketsUrl`, `imageUrl` | Direct checkout link and cover image. |
| `organizerId`, `organizerName`, `organizerUrl`, `organizerFollowers` | Who is running the event. |
| `venueName`, `venueAddress`, `venueCity`, `venueRegion`, `venuePostalCode`, `venueCountry` | Venue and full address. |
| `venueLatitude`, `venueLongitude` | Venue coordinates. |
| `distanceKm` | Great-circle distance from your search point - sort by this for true proximity. |
| `isOnlineEvent` | Whether the event has no physical venue. |
| `searchLatitude`, `searchLongitude`, `searchRadius`, `scrapedAt` | Provenance of the record. |

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

The Actor is efficient by design: it collects **50 events per request**, and ticket prices, venues, coordinates, and organizers all arrive in that same request rather than needing a visit to each event page. A typical city-wide run of a few thousand events uses only a handful of compute units, so it fits comfortably inside the free Apify plan's monthly credits.

Two things increase cost:

- **`scrapeEventDetails`** adds one request per event. Leave it off unless you need full descriptions.
- **Very dense areas over long date ranges** cause the Actor to split its search into smaller date windows (see below), which means more requests.

Start with `maxItems` set to a few hundred to gauge the cost of your particular search before running it unbounded.

### Tips and advanced options

- **Sort by `distanceKm`** to get true nearest-first ordering; Eventbrite's own ordering is relevance-based.
- **Use a smaller radius** for dense cities. It is both faster and more complete.
- **Narrow the date range** with `startDate`/`endDate` when you only care about, say, the next two weeks. This is the single biggest speed-up.
- **Filter by category** to cut a huge search into a manageable one.
- **`searchConcurrency`** raises throughput; lower it to be gentler on Eventbrite.
- **Coordinates from Google Maps**: right-click a spot and click the latitude/longitude to copy it.

#### A note on completeness

Eventbrite's search never returns more than about 950 results for a single query, no matter how many events match. To get around this, the Actor checks how many matches a date range has and, when it exceeds what can be paged through, automatically splits that range into smaller windows and searches each one. This is what lets a busy city return far more than 950 events.

The one case it cannot solve is a **single day** with more than ~950 matching events in your radius. When that happens the Actor logs an explicit warning naming the affected day, rather than quietly returning partial data. Narrowing the radius or adding a category filter resolves it.

### FAQ

**Do I need an Eventbrite API key?**
No. The Actor needs no Eventbrite account, key, or login.

**Can I search by city name instead of coordinates?**
Not directly - this Actor is built around coordinates so you can search areas that do not match a city boundary. Look up a city's latitude/longitude once (Google Maps, or any geocoding service) and reuse it.

**Why are some events missing a price?**
Organizers can hide pricing until checkout, and external-ticketing events may not expose it. Those records have `null` prices and `isFree: null`.

**The run failed with "Could not obtain a CSRF token" or HTTP 403/405. What now?**
Eventbrite is refusing requests from the IP address the run is using. This is most common on cloud datacenter IP ranges. Open **Proxy configuration** in the Input tab and switch Apify Proxy to the **RESIDENTIAL** group, then run again. The error message names the remedy and says whether a proxy was actually in use, so it is worth reading in full.

**Why is `subcategory` sometimes empty even though I filtered by one?**
Eventbrite classifies events internally but does not always publish the subcategory on the event record. Filtering still works correctly - you get exactly the events in that subcategory - but the field itself can come back empty for some of them. The Actor reports what Eventbrite actually publishes rather than filling the value in from your filter.

**Why do I get fewer events than Eventbrite's website shows?**
Eventbrite's site counters are approximate and often report a capped figure like 10,000. The Actor reports what it actually retrieved.

**Are online events included?**
They are excluded by default, since they have no physical location. Set `includeOnlineEvents` to `true` to keep them.

**Can I run this on a schedule?**
Yes. Use Apify's **Schedules** to run it hourly, daily, or weekly, and connect a webhook or integration to push new events wherever you need them.

### Disclaimer and support

This Actor collects **publicly available data only** - the same information any visitor can see on Eventbrite without logging in. It does not collect private or personal data behind a login. You are responsible for how you use the scraped data, including compliance with Eventbrite's Terms of Service, applicable copyright, and data protection law such as GDPR. If you plan to store or process personal data, make sure you have a legal basis for doing so.

Eventbrite may change its website at any time, which can affect the Actor. If something looks wrong or you need an extra field, please open an issue in the **Issues** tab and it will be looked into. Custom versions and bespoke scraping solutions can also be arranged on request.

# Actor input Schema

## `latitude` (type: `number`):

Latitude of the point to search around, in decimal degrees (-90 to 90).

## `longitude` (type: `number`):

Longitude of the point to search around, in decimal degrees (-180 to 180).

## `radius` (type: `integer`):

How far from the coordinates to search. Smaller radiuses return more complete results in dense cities.

## `radiusUnit` (type: `string`):

Unit for the search radius.

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

Only return events in this Eventbrite category. Leave empty for all categories.

## `subcategory` (type: `string`):

Only return events in this subcategory. Subcategory names repeat across categories, so each option is shown as "Category > Subcategory". A subcategory overrides the category above when both are set.

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

Optional free-text search, for example "yoga" or "startup pitch".

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

Only return events starting on or after this date (YYYY-MM-DD). Defaults to today. Eventbrite does not serve past events.

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

Only return events starting on or before this date (YYYY-MM-DD). Defaults to one year from the start date.

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

Restrict results to free or paid events.

## `includeOnlineEvents` (type: `boolean`):

Online events have no physical venue, so they are dropped by default. Turn this on to keep any that the location search returns.

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

Stop after this many events. Set to 0 to collect every matching event with no limit.

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

Fetch each event's full description. This costs one extra request per event and makes the run noticeably slower and more expensive. All other fields, including ticket prices and venue coordinates, are collected either way.

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

Proxy settings. If the run fails with 'Could not obtain a CSRF token' or HTTP 403/405, Eventbrite is blocking the IP address: switch Apify Proxy to the RESIDENTIAL group, which resolves it.

## `searchConcurrency` (type: `integer`):

How many date windows to search in parallel. Raise for speed, lower to be gentler on Eventbrite.

## `detailConcurrency` (type: `integer`):

How many event descriptions to fetch in parallel. Only used when "Scrape full descriptions" is on.

## Actor input object example

```json
{
  "latitude": 40.7128,
  "longitude": -74.006,
  "radius": 2,
  "radiusUnit": "km",
  "priceFilter": "any",
  "includeOnlineEvents": false,
  "maxItems": 50,
  "scrapeEventDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "searchConcurrency": 5,
  "detailConcurrency": 10
}
```

# 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 = {
    "latitude": 40.7128,
    "longitude": -74.006
};

// Run the Actor and wait for it to finish
const run = await client.actor("sigma-dev/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 = {
    "latitude": 40.7128,
    "longitude": -74.006,
}

# Run the Actor and wait for it to finish
run = client.actor("sigma-dev/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 '{
  "latitude": 40.7128,
  "longitude": -74.006
}' |
apify call sigma-dev/eventbrite-scraper --silent --output-dataset

```

## MCP server setup

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