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

Scrape public Eventbrite events from search, discovery, category, location, and event URLs. Export dates, venues, organizers, prices, tags, and event links.

- **URL**: https://apify.com/fetch\_cat/eventbrite-events-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.04 / 1,000 event saveds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Events Scraper

Scrape public Eventbrite event listings and event details from discovery, search, category, location, and direct event URLs. Export clean event data to CSV, JSON, Excel, API, or webhooks for market research, event monitoring, lead generation, and organizer analysis.

### Value proposition

Collect public Eventbrite event data quickly without manual copying, then export structured rows for research, lead generation, monitoring, and automation.

### What it does

Eventbrite Events Scraper turns public Eventbrite event pages into structured rows with event IDs, URLs, titles, dates, venues, organizer details, categories, tags, prices, images, and diagnostics. It is best for teams that need repeatable event data instead of manual copy-paste from Eventbrite search pages.

### Who is this for?

- **Event marketers** tracking competing events, formats, prices, and organizers.
- **Lead generation teams** building lists of organizers, venues, and upcoming events.
- **Researchers and analysts** monitoring event volume by city, topic, or community.
- **Automation builders** sending event data into CRMs, sheets, dashboards, or agents.

### What you can do

- **Track event markets**: collect upcoming events for a city, category, format, or online event page.
- **Build lead lists**: export organizer names, event URLs, venue details, categories, tags, and pricing signals.
- **Monitor competitors or communities**: schedule repeat runs and compare fresh Eventbrite results over time.
- **Enrich curated event lists**: paste direct Eventbrite event URLs and fetch structured details.

### Input recipes

- **Online events smoke test**: `https://www.eventbrite.com/d/online/events/` with `maxItems: 20`.
- **City/category research**: `https://www.eventbrite.com/d/united-states--new-york/business--events/` with `maxItems: 50`.
- **Direct event enrichment**: paste one or more public Eventbrite event URLs and keep `includeEventDetails: true`.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.eventbrite.com/d/online/events/" }
  ],
  "maxItems": 20,
  "maxPages": 2,
  "includeEventDetails": true,
  "dedupeEvents": true
}
````

### Example output

```json
{
  "itemType": "event",
  "eventId": "1992487337262",
  "eventUrl": "https://www.eventbrite.co.uk/e/what-determines-which-businesses-get-chosen-online-tickets-1992487337262",
  "title": "What Determines Which Businesses Get Chosen Online?",
  "descriptionText": "Online buyers rely on trust signals across your whole digital presence.",
  "startDate": "2026-07-29T13:00:00Z",
  "endDate": "2026-07-29T14:00:00Z",
  "isOnline": true,
  "organizerName": "Digital Safety CIC",
  "organizerUrl": "https://www.eventbrite.co.uk/o/digital-safety-cic-111504277211",
  "priceText": "Free",
  "currency": "GBP",
  "isFree": true,
  "status": "live",
  "sourceUrl": "https://www.eventbrite.com/d/online/events/",
  "scrapedAt": "2026-07-15T09:07:56.212Z"
}
```

### Input settings

| Setting | JSON key | Description | Default |
| --- | --- | --- | --- |
| Eventbrite URLs | `startUrls` | Public Eventbrite discovery/search/category/location URLs or direct event URLs. | Online events page |
| Maximum events | `maxItems` | Maximum event rows to save. | `20` |
| Maximum search pages | `maxPages` | Maximum discovery pages to request per input URL. | `3` |
| Fetch event details | `includeEventDetails` | Fetch richer public event, venue, organizer, and ticket fields. | `true` |
| Dedupe events | `dedupeEvents` | Skip duplicate events across multiple input URLs. | `true` |

### What data can you extract?

The default dataset contains event rows and diagnostic rows for public Eventbrite inputs.

### Output fields

| Field | Description |
| --- | --- |
| `itemType` | `event` for event rows or `error` for diagnostics. |
| `eventId`, `eventUrl`, `title` | Stable Eventbrite ID, canonical URL, and event title. |
| `descriptionText` | Public event description text when available. |
| `startDate`, `endDate`, `rawDateText`, `timezone` | Parsed and raw event date/time information. |
| `isOnline`, `venueName`, `venueAddress`, `city`, `region`, `country`, `latitude`, `longitude` | Online/venue and location data when public. |
| `organizerName`, `organizerUrl` | Public organizer information. |
| `category`, `tags` | Event category and tag labels. |
| `priceText`, `minPrice`, `currency`, `isFree` | Public ticket price signals. |
| `imageUrl`, `status` | Event image and public status. |
| `sourceUrl`, `scrapedAt` | Input URL and scrape timestamp. |
| `errorCode`, `errorMessage` | Present on diagnostic rows for invalid, empty, blocked, or unavailable inputs. |

### Pricing

| Event | Price | Charged when |
| --- | --- | --- |
| Run start | `$0.005` per run | Once when the Actor starts. |
| Event saved | Bronze `$0.000068354` per event row, with tier discounts | Each event row saved to the dataset. Error rows are not charged as event results. |

Volume tiers: Free `$0.000078607`, Bronze `$0.000068354`, Silver `$0.000053316`, Gold `$0.000041012`, Platinum `$0.000027341`, and Diamond `$0.000019139` per event row.

### Tips and limits

- Start with `maxItems: 20` to verify the URL and output before scaling.
- Use public Eventbrite pages only. This Actor does not access private events, attendee lists, orders, carts, organizer dashboards, or account-only data.
- If one input fails, other valid inputs continue and the failed input is reported as an `error` row.
- Broad discovery pages can contain duplicate events; keep `dedupeEvents` enabled for most runs.

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/eventbrite-events-scraper').call({
  startUrls: [{ url: 'https://www.eventbrite.com/d/online/events/' }],
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/eventbrite-events-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.eventbrite.com/d/online/events/'}],
    'maxItems': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~eventbrite-events-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.eventbrite.com/d/online/events/"}],"maxItems":20}'
```

### MCP / agents

Use this Actor in Apify MCP-compatible agents with the tool URL:

```text
https://mcp.apify.com/?tools=fetch_cat/eventbrite-events-scraper
```

Claude CLI example:

```bash
claude mcp add apify-eventbrite-events "https://mcp.apify.com/?tools=fetch_cat/eventbrite-events-scraper"
```

JSON config example:

```json
{
  "mcpServers": {
    "apify-eventbrite-events": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/eventbrite-events-scraper"
    }
  }
}
```

Example prompts:

- "Find 20 upcoming online Eventbrite events and summarize the organizer categories."
- "Scrape this Eventbrite city category URL and return event titles, dates, and prices."

### Related actors

- [Meetup Events Scraper](https://apify.com/fetch_cat/meetup-events-scraper) for public Meetup event data.
- [Website Content Crawler Lite](https://apify.com/fetch_cat/website-content-crawler-lite) for downstream website enrichment.
- [Google Maps Places Scraper](https://apify.com/fetch_cat/google-maps-places-scraper) for venue and local business research.

### FAQ

**Can it scrape private Eventbrite data?** No. It only works with public Eventbrite pages and public event metadata.

**Will one bad URL stop the whole run?** No. Failed inputs are reported as `itemType: error` rows while other valid inputs continue.

**Should I use discovery URLs or direct event URLs?** Use discovery URLs for market research and direct event URLs when you already have a curated list to enrich.

### Support

If a public Eventbrite URL returns no events or an error row, include the following in your support request:

- **Run ID or run URL** from Apify.
- **Input JSON** used for the run.
- **Expected output** such as the event title, date, or URL you expected to see.
- **Actual output** including any `errorCode` and `errorMessage` rows.
- **Reproducible public URL** from Eventbrite.

We do not support scraping private or account-only Eventbrite data.

# Actor input Schema

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

Public Eventbrite discovery/search/category/location URLs or direct event URLs.

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

Maximum number of event rows to save. Error rows are not charged as event results.

## `maxPages` (type: `integer`):

Maximum Eventbrite discovery pages to request per input URL.

## `includeEventDetails` (type: `boolean`):

Fetch each event detail endpoint for richer description, venue, organizer, and ticket availability fields.

## `dedupeEvents` (type: `boolean`):

Skip duplicate events seen across multiple input URLs using Eventbrite event ID or canonical URL.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.eventbrite.com/d/online/events/"
    }
  ],
  "maxItems": 20,
  "maxPages": 3,
  "includeEventDetails": true,
  "dedupeEvents": true
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.eventbrite.com/d/online/events/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/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 = { "startUrls": [{ "url": "https://www.eventbrite.com/d/online/events/" }] }

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/eventbrite-events-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 '{
  "startUrls": [
    {
      "url": "https://www.eventbrite.com/d/online/events/"
    }
  ]
}' |
apify call fetch_cat/eventbrite-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eventbrite Events Scraper",
        "description": "Scrape public Eventbrite events from search, discovery, category, location, and event URLs. Export dates, venues, organizers, prices, tags, and event links.",
        "version": "0.1",
        "x-build-id": "0uwdLIGIp9O26osOe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~eventbrite-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-eventbrite-events-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/fetch_cat~eventbrite-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-eventbrite-events-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/fetch_cat~eventbrite-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-eventbrite-events-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Eventbrite URLs",
                        "type": "array",
                        "description": "Public Eventbrite discovery/search/category/location URLs or direct event URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum events",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of event rows to save. Error rows are not charged as event results.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Maximum search pages",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum Eventbrite discovery pages to request per input URL.",
                        "default": 3
                    },
                    "includeEventDetails": {
                        "title": "Fetch event details",
                        "type": "boolean",
                        "description": "Fetch each event detail endpoint for richer description, venue, organizer, and ticket availability fields.",
                        "default": true
                    },
                    "dedupeEvents": {
                        "title": "Dedupe events",
                        "type": "boolean",
                        "description": "Skip duplicate events seen across multiple input URLs using Eventbrite event ID or canonical URL.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
