# Eventbrite Events Intel - Discovery, Organizers, Prices (`seibs.co/eventbrite-events-intel`) Actor

Discover and normalize public Eventbrite events by location, category, keyword, and date - the event-discovery layer Eventbrite removed from its API in 2020. Returns name, organizer, venue, date, price tiers, and availability plus organizer rollups. For event marketers, sponsors, and lead-gen.

- **URL**: https://apify.com/seibs.co/eventbrite-events-intel.md
- **Developed by:** [Seibs.co](https://apify.com/seibs.co) (community)
- **Categories:** Business, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 event records

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 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

## Eventbrite Events Intel

**Discover and normalize public Eventbrite events by location, category, keyword, and date - the discovery layer Eventbrite removed from its API in 2020.**

Eventbrite **shut off its public Event Search API in February 2020**. The official API can only return *your own* organization's events - there is no approval, no tier, no application that re-opens cross-organizer discovery. If you want to find *other people's* events (to market alongside them, sponsor them, prospect their exhibitors, or track competitors), the API simply cannot do it. The data still lives on Eventbrite's public, logged-out web. This actor reconstructs the discovery layer from those public pages and hands it back as one clean, normalized schema - no application required. **The closed API is the moat.**

Built for the buyers the API locks out: **event marketers, sponsors, lead-gen teams, and competitive event trackers.**

***

### What you get

- **Event discovery** by location, category, keyword, and date - the search the API can't do.
- **Normalized event records**: name, organizer, venue + full address & geo, start/end date-time, timezone, category / subcategory / format, tags, online flag, status, image, tickets URL.
- **Price & ticket enrichment** (opt-in): price range + tiers, availability / urgency signals ("few tickets left"), organizer, and performers parsed from the event page.
- **Organizer rollups**: each organizer's event count, categories, venues, cities, date span, online/free counts, and price range - the competitive-intel layer.
- **New-event monitor mode**: schedule the actor and it emits a digest of newly-listed events since the last run (Slack/webhook optional).

### Modes

| Mode | What it does | Required input |
|---|---|---|
| `discover` | Find events by location / category / keyword / date, then roll up by organizer | `location` + (`category` and/or `keyword`) |
| `event_detail` | Enrich specific event URLs with price tiers, organizer, performers | `event_urls` |
| `organizer_events` | Pull an organizer's public upcoming events | `organizer_urls` |

New-event monitoring turns on automatically when the actor runs under an Apify Schedule.

### Example input

```json
{
  "mode": "discover",
  "location": "ny--new-york",
  "category": "music",
  "keyword": "jazz",
  "date_from": "2026-07-01",
  "date_to": "2026-07-31",
  "include_pricing": true,
  "max_results_per_query": 50
}
```

`location` is the Eventbrite **location slug** - the part after `/d/` in any Eventbrite discovery URL (e.g. `ny--new-york`, `ca--los-angeles`, `tx--austin`, `il--chicago`, or `online`). Pass `locations`, `categories`, and `keywords` arrays to fan out across many in one run.

### Example output (event record)

```json
{
  "record_type": "event",
  "event_id": "...",
  "name": "Refuge Thursday w/ Todd Terje (DJ Set)",
  "url": "https://www.eventbrite.com/e/...",
  "start_local": "2026-07-10T22:00:00",
  "timezone": "America/New_York",
  "category": "Music",
  "subcategory": "House",
  "organizer_name": "Refuge.NYC",
  "venue_name": "Refuge",
  "venue_address": "...",
  "city": "Brooklyn", "region": "NY", "country": "US",
  "price_min": 25.0, "price_max": 65.0, "price_currency": "USD",
  "price_label": "$25 - $65", "is_free": false,
  "availability": "InStock",
  "performers": [{"name": "Todd Terje", "url": "..."}],
  "source": "event_page"
}
```

Organizer rollups (`record_type: organizer_rollup`) carry `event_count`, `categories`, `venues`, `first_event_date` / `last_event_date`, `online_event_count`, `free_event_count`, and `price_min` / `price_max`.

### Output views

`overview` (default, token-efficient for AI agents), `events` (every field), `organizers` (rollups), plus CSV and an MCP-compatible JSON slice. There is also a companion **MCP server** (`mcp-eventbrite-events-intel`) that exposes these as AI-agent tools with x402 / Skyfire agentic-payment support.

### Pricing (pay-per-event)

| Event | Price | What it is |
|---|---|---|
| `event_record` | **$0.005** | One normalized public event |
| `price_ticket_enrichment` | **$0.010** | Price range / tiers, availability, organizer, performers from the event page |
| `organizer_rollup` | **$0.015** | One organizer's aggregate event profile |
| `scheduled_delta_run` | **$0.030** | One scheduled new-event monitor delta |

A run that returns nothing costs nothing.

### How it works (anti-bot)

Eventbrite fronts its pages with an edge WAF that fingerprints the caller's TLS and can 403 a plain datacenter request. The actor uses a **three-tier escalation ladder** and fails soft if every tier is blocked:

1. **httpx** over the DATACENTER proxy - cheapest, first.
2. **curl\_cffi** with real Chrome TLS impersonation over the RESIDENTIAL proxy - defeats JA3/TLS-fingerprint WAFs.
3. **Playwright** (patchright stealth) headful Chromium over the RESIDENTIAL proxy - for a true JS/Cloudflare interstitial (optional; set `browser_cdp_url` / `BROWSER_CDP_URL` for a warm anti-detect browser).

Discovery also uses Eventbrite's logged-out internal destination-search endpoint (seeding the `csrftoken` cookie from the homepage) to page through full result sets and apply keyword + date filters - the same data the removed Search API once returned.

### Responsible use & legal posture

- **Logged-out, public pages only.** No login, no accounts, no user cookies, no paywalled data.
- **PII minimized.** We keep public event / organizer / venue facts only - never attendee, buyer, or private contact data.
- **Polite rate limits** and automatic fail-soft when blocked.
- This is public-event-listing data; verify any single record before acting on it, and respect Eventbrite's terms and applicable law in your jurisdiction.

# Actor input Schema

## `mode` (type: `string`):

discover = find events by location/category/keyword/date and roll them up by organizer (the core wedge). event\_detail = enrich specific event URLs with price tiers, availability, organizer, and performers. organizer\_events = pull an organizer's public upcoming events. New-event monitoring is automatic when the actor runs under an Apify Schedule.

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

Eventbrite location slug, e.g. 'ny--new-york', 'ca--los-angeles', 'tx--austin', 'il--chicago', or 'online'. The slug is the part after /d/ in an Eventbrite discovery URL. Used in discover mode.

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

Query several location slugs in one run, e.g. \['ny--new-york', 'ca--san-francisco', 'online']. Overrides 'location' when set. Hard cap of 20.

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

Eventbrite category slug or id: music, business, food-and-drink, community, arts, film-and-media, sports-fitness, health, science-and-tech, travel-outdoor, charity-and-causes, spirituality, family-education, holiday, government, fashion, home-and-lifestyle, auto-boat-and-air, hobbies, school-activities, other. Used in discover mode (with or without a keyword).

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

Several category slugs in one run, e.g. \['music', 'business']. Combines with each keyword. Hard cap of 25.

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

Free-text search within the location, e.g. 'jazz', 'startup pitch', 'wine tasting'. Combine with a category to narrow further. Used in discover mode.

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

Several keyword queries in one run, e.g. \['jazz', 'hip hop']. Each is crossed with each location (and category). Hard cap of 25.

## `date_from` (type: `string`):

Only events starting on/after this date, e.g. '2026-07-01'. Leave blank for current + future events.

## `date_to` (type: `string`):

Only events starting on/before this date, e.g. '2026-07-31'.

## `dates_token` (type: `string`):

Instead of explicit dates, use a relative window. Ignored when date\_from/date\_to are set.

## `event_urls` (type: `array`):

Eventbrite event page URLs to enrich, e.g. \['https://www.eventbrite.com/e/<slug>-tickets-<id>']. Required for event\_detail mode. Hard cap of 200.

## `organizer_urls` (type: `array`):

Eventbrite organizer page URLs, e.g. \['https://www.eventbrite.com/o/<slug>-<id>']. Required for organizer\_events mode. Hard cap of 25.

## `include_pricing` (type: `boolean`):

In discover mode, fetch each event's detail page to add price range, ticket availability, organizer name, and performers. Charges price\_ticket\_enrichment per event that yields a price/performer layer. Off by default for a fast, cheap discovery pass.

## `emit_organizer_rollups` (type: `boolean`):

Aggregate the event set by organizer: event count, categories, venues, date span, and price range - the competitive-intel layer. Charges organizer\_rollup per organizer emitted.

## `max_results_per_query` (type: `integer`):

Cap on events returned per (location x category x keyword) query in discover mode. Default 50.

## `max_organizer_events` (type: `integer`):

Cap on events pulled per organizer in organizer\_events mode. Default 25.

## `monitor_webhook_url` (type: `string`):

When this actor runs under an Apify Schedule (monitor mode), post the new-events digest to this Slack-compatible webhook URL.

## `use_apify_proxy` (type: `boolean`):

Route requests through Apify Proxy. The DATACENTER tier handles the first (httpx) pass; a RESIDENTIAL tier is provisioned for anti-bot escalation.

## `use_browser_fallback` (type: `boolean`):

When Eventbrite serves a 403/Cloudflare challenge from a datacenter IP, automatically escalate: switch to the RESIDENTIAL proxy and retry with curl\_cffi Chrome TLS impersonation, then (if available) a headless browser. Turn off to use plain httpx only.

## `browser_cdp_url` (type: `string`):

Optional CDP/WebSocket endpoint of an already-running, anti-detect (UC-mode / real Chrome) browser. When set, the browser tier connects to it (inheriting its session + fingerprint) to pass a managed Cloudflare challenge. Can also be set as the BROWSER\_CDP\_URL env var.

## `apify_proxy_groups` (type: `array`):

Override the auto-selected proxy group. Leave empty to let the actor pick DATACENTER (httpx) + RESIDENTIAL (escalation).

## `concurrency` (type: `integer`):

Parallel fetches. Eventbrite is rate-sensitive; default 4.

## Actor input object example

```json
{
  "mode": "discover",
  "location": "ny--new-york",
  "locations": [],
  "category": "music",
  "categories": [],
  "keyword": "",
  "keywords": [],
  "date_from": "",
  "date_to": "",
  "dates_token": "",
  "event_urls": [],
  "organizer_urls": [],
  "include_pricing": false,
  "emit_organizer_rollups": true,
  "max_results_per_query": 50,
  "max_organizer_events": 25,
  "monitor_webhook_url": "",
  "use_apify_proxy": true,
  "use_browser_fallback": true,
  "browser_cdp_url": "",
  "apify_proxy_groups": [],
  "concurrency": 4
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

Narrow, token-efficient slice of every record. Consumer: LLM agents (Claude, GPT, LangChain tools), MCP hosts, event dashboards.

## `datasetItemsEvents` (type: `string`):

Full normalized events with venue, date/time, price tiers, organizer, and performers. Consumer: lead-gen, sponsorship prospecting, CRM enrichment, RAG ingest.

## `datasetItemsOrganizers` (type: `string`):

One row per organizer: event count, categories, venues, date span, price range. Consumer: competitive event tracking, sponsor prospecting.

## `datasetItemsMcp` (type: `string`):

First 50 overview records as a clean JSON array. Wrap on the agent side in an MCP tool-call envelope. Consumer: MCP servers, Claude Desktop, Cursor, OpenAI Assistants tool calls.

## `datasetItemsCsv` (type: `string`):

Spreadsheet-friendly export of the overview view. Consumer: event marketers, sponsors, Excel / Google Sheets users.

# 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 = {
    "mode": "discover",
    "location": "ny--new-york",
    "category": "music",
    "keyword": "",
    "max_results_per_query": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("seibs.co/eventbrite-events-intel").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 = {
    "mode": "discover",
    "location": "ny--new-york",
    "category": "music",
    "keyword": "",
    "max_results_per_query": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("seibs.co/eventbrite-events-intel").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 '{
  "mode": "discover",
  "location": "ny--new-york",
  "category": "music",
  "keyword": "",
  "max_results_per_query": 50
}' |
apify call seibs.co/eventbrite-events-intel --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/mwGL7iYu42vjwa1Ba/builds/CtCxb6bhLWGXnwlbv/openapi.json