# Eventbrite Events Scraper — Search, Venue, Organizer & Tickets (`khadinakbar/eventbrite-events-scraper`) Actor

Scrape Eventbrite events by URL, city, category, date, or free-text search. Returns 30+ fields per event: title, ISO dates, venue with GPS coords, organizer, ticket prices, tags, images. Three input modes, pagination to ~1K events. MCP-ready, auth-free.

- **URL**: https://apify.com/khadinakbar/eventbrite-events-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

### What does Eventbrite Events Scraper do?

**Eventbrite Events Scraper** extracts **30+ fields per event** from [Eventbrite.com](https://www.eventbrite.com) — including title, ISO 8601 start/end dates with timezone, full venue address with GPS coordinates, organizer details, ticket price tiers, category and format tags, and high-resolution image variants. Three input modes: direct event URLs, free-text search, or filter combinations (city + category + date + format). Auth-free, no cookies. Built to be **MCP-ready** so Claude, ChatGPT, and other AI agents can call it as a tool out of the box. Pagination handled automatically up to ~1,000 events per filter combination.

Run on the Apify platform for scheduled extraction, API access, integrations (Zapier, Make, Slack, Google Sheets), residential proxy rotation, monitoring, and usage-based billing — or run the Actor on demand and download results as JSON, CSV, or Excel.

### Why use Eventbrite Events Scraper?

- **Event aggregation platforms** — populate a city events feed, niche directory, or curated calendar with structured data.
- **Hospitality and tourism** — feed event-driven demand signals to hotel revenue management, restaurant booking, and ride-share pricing systems.
- **Sponsorship and partnership prospecting** — build organizer lead lists by city, category, and event format.
- **Market and competitive research** — track conferences, festivals, and meetups in your industry over time.
- **AI agents and LLM workflows** — give your agent a single tool for answering "what's happening in San Francisco next weekend?"
- **Lead generation** — capture organizer profile URLs to feed into outreach pipelines.
- **Personal projects and dashboards** — populate an events widget, run trend analysis, build a Slack notifier.

### How to scrape Eventbrite events: step-by-step

1. **Click "Try for free"** at the top of this page (sign in to Apify or create a free account).
2. **Pick an input mode** in the Input tab:
   - **Free-text search**: type a `searchQuery` like `"jazz concert"` and optionally a `location` slug like `"ca--san-francisco"`.
   - **Filter browse**: leave `searchQuery` empty and pick `location`, `category`, `dateFilter`, `format`, and `priceFilter` from the dropdowns.
   - **Direct URLs**: paste Eventbrite browse or event detail URLs into `startUrls`.
3. **Set `maxResults`** (default 50). Each event extracted is one billable event.
4. **Leave `includeDetails: true`** (default) to fetch full description, organizer name, and ticket tiers from each event's detail page. Disable for a cheaper "list-only" run.
5. **Click "Start"**. Watch the live log; partial results stream to the Dataset tab as they're scraped.
6. **Download** the dataset as JSON, CSV, Excel, RSS, or query the [Apify Dataset API](https://docs.apify.com/api/v2#/reference/datasets) directly.

### Input

The Input tab in Apify Console renders a form for the input fields below. All fields are optional — provide at least ONE of `searchQuery`, `location`, or `startUrls`.

```json
{
    "searchQuery": "tech conference",
    "location": "ny--new-york",
    "category": "business",
    "dateFilter": "this-month",
    "format": "conference",
    "priceFilter": "",
    "onlineOnly": false,
    "maxResults": 50,
    "includeDetails": true
}
````

#### Location slugs

Eventbrite uses URL slugs (not free-text names) for cities and countries. Examples:

- `ny--new-york`
- `ca--los-angeles`
- `ca--san-francisco`
- `il--chicago`
- `tx--austin`
- `united-kingdom--london`
- `united-states` (country-wide)
- `online` (all online events)

The full list is browsable at [eventbrite.com/d/](https://www.eventbrite.com/d/).

### Output

Each event becomes one record in the default Dataset with 30+ fields. Sample:

```json
{
    "eventId": "1977459767396",
    "name": "Friday Night Lights at Mama Taco",
    "summary": "Get in early and party free before midnight with RSVP for a night full of good vibes.",
    "description": "Full event description in plain text...",
    "url": "https://www.eventbrite.com/e/friday-night-lights-...",
    "startDate": "2026-05-15T20:00:00",
    "endDate": "2026-05-16T04:00:00",
    "timezone": "America/New_York",
    "isOnline": false,
    "isFree": false,
    "venueName": "MAMATACO",
    "venueAddress": "880 Flushing Avenue, Brooklyn, NY 11206",
    "venueCity": "Brooklyn",
    "venueRegion": "NY",
    "venueCountry": "US",
    "venuePostalCode": "11206",
    "venueLatitude": 40.701824,
    "venueLongitude": -73.936648,
    "category": "Music",
    "subcategory": "Hip Hop / Rap",
    "format": "Party or Social Gathering",
    "tags": ["Reggae", "Afrobeats", "Hiphopmusic"],
    "organizerId": "5494940201",
    "organizerName": "JiggyTime Ent",
    "organizerUrl": "https://www.eventbrite.com/o/jiggytime-ent-5494940201",
    "priceMin": 0,
    "priceMax": 55.2,
    "currency": "USD",
    "ticketTiers": [
        { "name": "aggregate", "priceLow": 0, "priceHigh": 55.2, "currency": "USD", "availability": "InStock" }
    ],
    "ticketsUrl": "https://www.eventbrite.com/e/...",
    "imageUrl": "https://img.evbuc.com/...?w=640",
    "imageUrlOriginal": "https://img.evbuc.com/...?original",
    "scrapedAt": "2026-05-13T15:55:00.000Z"
}
```

Download as JSON, CSV, Excel, HTML table, or RSS from the Dataset tab.

### Data fields extracted

| Field | Type | Description |
|---|---|---|
| `eventId`, `eventbriteId`, `eid` | string | Eventbrite event identifiers |
| `name`, `summary`, `description` | string | Event title, short summary, full description |
| `url`, `slug` | string | Canonical Eventbrite URL and URL slug |
| `startDate`, `endDate`, `timezone` | string | ISO 8601 dates with IANA timezone |
| `isOnline`, `isCancelled`, `isFree` | boolean | Status flags |
| `language` | string | Event language code |
| `venueName`, `venueAddress`, `venueCity`, `venueRegion`, `venueCountry`, `venuePostalCode` | string | Full venue address |
| `venueLatitude`, `venueLongitude` | number | WGS84 GPS coordinates |
| `venueId` | string | Eventbrite venue ID |
| `category`, `categorySlug`, `subcategory`, `format` | string | Eventbrite taxonomy |
| `tags` | array | Organizer-applied free-text tags |
| `organizerId`, `organizerName`, `organizerUrl`, `organizerWebsite` | string | Organizer profile |
| `priceMin`, `priceMax`, `currency` | number/string | Lowest and highest ticket prices |
| `ticketTiers` | array | Per-tier price objects with name, price, availability |
| `ticketsUrl`, `ticketsBy` | string | Ticket purchase URL and provider |
| `imageUrl`, `imageUrlLarge`, `imageUrlSmall`, `imageUrlOriginal` | string | Cover image variants |
| `imageWidth`, `imageHeight` | integer | Original image dimensions |
| `publishedAt`, `scrapedAt` | string | Publish and scrape timestamps |

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

This Actor uses **pay-per-event** monetization (charge happens only for what you actually receive). Pay-per-usage (compute units + proxy passthrough) is also enabled for power users who prefer compute-tier pricing on very large jobs.

| Event | Price |
|---|---|
| Actor start | $0.00005 per GB of memory (1 event per run start) |
| `event-scraped` | **$0.005** per event returned in the dataset |

**Typical run costs:**

- 50 events (default agent call): ≈ **$0.25**
- 500 events: ≈ **$2.50**
- 1,000 events (single-filter max): ≈ **$5.00**

Memberships:

- Free tier: same pricing.
- Paid Apify plans receive the standard volume discounts on platform compute.

### Tips and advanced options

- **Lower the cost** by setting `includeDetails: false` to skip per-event detail fetches — you still get 25+ fields from the browse listing.
- **Speed up runs** by reducing `maxResults`. The Actor stops as soon as the limit is hit; pagination only advances when more events are needed.
- **Bulk extraction** at scale: combine multiple narrow filter combinations (one per city or category) rather than one giant query — Eventbrite caps a single filter combination at ~1,000 events.
- **Online-only events**: set `onlineOnly: true` (location is ignored when true).
- **Proxy**: residential is the default and recommended. Datacenter works for small runs (≤200 events) and is cheaper, but may hit rate limits on long crawls.
- **Schedule recurring runs** from the Schedules tab to keep an events database fresh. Combine with Apify's Slack, Email, or webhook integrations to get notified when new events are added.

### Integrations

This Actor works with:

- **Apify API** — programmatic runs, dataset access, scheduling
- **Zapier**, **Make**, **n8n** — no-code automation
- **Google Sheets**, **Airtable** — direct dataset sync
- **Slack**, **Discord**, **Telegram**, **Email** — run notifications
- **Apify MCP server** — call this Actor directly from Claude, ChatGPT, Gemini, or any MCP-compatible agent at `apify--eventbrite-events-scraper`

### FAQ

**Is scraping Eventbrite legal?**
This Actor extracts only publicly available event data shown on Eventbrite browse and event detail pages — the same data any visitor can see in their browser. Always review Eventbrite's Terms of Service and your local regulations before scraping at scale. Don't scrape private data, attendee information, or anything behind a login.

**Does it bypass Eventbrite's API rate limits?**
This Actor doesn't use the Eventbrite API — it reads the public HTML pages. There's no Eventbrite API token required and no API-level rate limits to worry about. Heavy users should still respect Eventbrite's robots.txt and pace their runs (residential proxy + session pool handles this automatically).

**Why are some price fields empty?**
For events without published ticket prices (RSVP-only, "free with RSVP", external ticketing), Eventbrite may not include structured pricing data. `isFree: true` is set when both `priceMin` and `priceMax` are 0; for RSVP-only events you may see empty price fields.

**Can it scrape attendee data?**
No — attendee data is private and requires Eventbrite organizer credentials. This Actor only extracts publicly visible event metadata.

**What if I need a different field or another event source?**
Open an issue on the Apify Issues tab for this Actor, or message us for a custom solution. We also build custom scrapers for Meetup, Lu.ma, Bandsintown, Songkick, and conference-specific platforms.

### Related Actors

- [LinkedIn Jobs Scraper](https://apify.com/khadinakbar/linkedin-jobs-scraper) — scrape LinkedIn job postings with salary and skills.
- [Universal Lead Finder](https://apify.com/khadinakbar/universal-lead-finder) — find leads in any niche + city.
- [Google Maps Leads Scraper](https://apify.com/khadinakbar/google-maps-leads-scraper) — B2B leads from Google Maps with emails.

### Disclaimer

This Actor scrapes only publicly available event data. It does not extract attendee information, private organizer data, or anything behind a login. Use of this Actor is subject to Eventbrite's Terms of Service and applicable laws. The Actor's authors are not responsible for any misuse.

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text keyword to search Eventbrite (e.g., 'tech conference', 'jazz concert', 'startup meetup'). Combined with location and date filters when provided. Leave empty when using startUrls or browsing by category alone. NOT an event ID and NOT an Eventbrite URL — for those use startUrls instead.

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

City or country slug used by Eventbrite (e.g., 'ny--new-york', 'ca--san-francisco', 'united-kingdom--london', 'united-states', 'online'). Format is two letters for state/region, double hyphen, then city name in lowercase with hyphens. Defaults to 'united-states' when omitted. NOT a free-text city name — must be the URL slug.

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

Eventbrite category slug to filter results (e.g., 'music', 'business', 'food-and-drink', 'health', 'arts', 'sports-and-fitness'). Leave empty for all categories. NOT a custom keyword — use searchQuery for that. See https://www.eventbrite.com/d/online/all-events/ for full list.

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

Date-range filter applied on top of search results. One of the predefined Eventbrite ranges (e.g., 'today', 'this-weekend', 'next-month'). Leave empty to include all upcoming events. NOT a YYYY-MM-DD date — Eventbrite browse pages only support predefined ranges.

## `format` (type: `string`):

Event format filter (e.g., 'conference', 'festival', 'class', 'networking'). Combined with category and location filters. Leave empty to include all formats. NOT an online-only flag — use the 'onlineOnly' boolean for that.

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

Filter by free or paid events only. Leave empty to include both. NOT a numeric price range — Eventbrite browse pages do not support arbitrary price ranges.

## `onlineOnly` (type: `boolean`):

Restrict results to virtual/online events. When true, location is ignored. Defaults to false (both in-person and online included).

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

Direct Eventbrite browse URLs or event page URLs to scrape. Use this for custom search filters not exposed by this Actor's inputs, or to scrape specific event detail pages. Any URL parameters are preserved (e.g., '?page=2'). Mutually exclusive with searchQuery and location — provide either startUrls OR the filter inputs, not both.

## `maxResults` (type: `integer`):

Maximum number of events to return. Eventbrite browse pages return 20 events per page with up to 49 pages per query (~1,000 events max per filter combination). Default 50 keeps run cost low for typical agent calls. Set higher for bulk extraction.

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

Fetch each event's detail page to extract full description, organizer name and profile URL, ticket tiers with prices, and structured pricing currency. When false, returns only browse-page fields (still 25+ fields). Adds one HTTP request per event but no extra event charge.

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

Apify proxy settings. Defaults to RESIDENTIAL group for reliability against Cloudflare image CDN. Datacenter works for low-volume runs but may get rate-limited at scale.

## Actor input object example

```json
{
  "searchQuery": "tech conference",
  "location": "ny--new-york",
  "onlineOnly": false,
  "maxResults": 50,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `events` (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 = {
    "location": "ny--new-york",
    "maxResults": 50,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "location": "ny--new-york",
    "maxResults": 50,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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 '{
  "location": "ny--new-york",
  "maxResults": 50,
  "includeDetails": true
}' |
apify call khadinakbar/eventbrite-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eventbrite Events Scraper — Search, Venue, Organizer & Tickets",
        "description": "Scrape Eventbrite events by URL, city, category, date, or free-text search. Returns 30+ fields per event: title, ISO dates, venue with GPS coords, organizer, ticket prices, tags, images. Three input modes, pagination to ~1K events. MCP-ready, auth-free.",
        "version": "0.4",
        "x-build-id": "lvVTTK9Ne3iP1ShDP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~eventbrite-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-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/khadinakbar~eventbrite-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-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/khadinakbar~eventbrite-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-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",
                "properties": {
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text keyword to search Eventbrite (e.g., 'tech conference', 'jazz concert', 'startup meetup'). Combined with location and date filters when provided. Leave empty when using startUrls or browsing by category alone. NOT an event ID and NOT an Eventbrite URL — for those use startUrls instead."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or country slug used by Eventbrite (e.g., 'ny--new-york', 'ca--san-francisco', 'united-kingdom--london', 'united-states', 'online'). Format is two letters for state/region, double hyphen, then city name in lowercase with hyphens. Defaults to 'united-states' when omitted. NOT a free-text city name — must be the URL slug."
                    },
                    "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",
                            "seasonal",
                            "government",
                            "fashion",
                            "home-and-lifestyle",
                            "auto-boat-and-air",
                            "hobbies",
                            "school-activities",
                            "other"
                        ],
                        "type": "string",
                        "description": "Eventbrite category slug to filter results (e.g., 'music', 'business', 'food-and-drink', 'health', 'arts', 'sports-and-fitness'). Leave empty for all categories. NOT a custom keyword — use searchQuery for that. See https://www.eventbrite.com/d/online/all-events/ for full list."
                    },
                    "dateFilter": {
                        "title": "Date filter",
                        "enum": [
                            "",
                            "today",
                            "tomorrow",
                            "this-weekend",
                            "this-week",
                            "next-week",
                            "this-month",
                            "next-month"
                        ],
                        "type": "string",
                        "description": "Date-range filter applied on top of search results. One of the predefined Eventbrite ranges (e.g., 'today', 'this-weekend', 'next-month'). Leave empty to include all upcoming events. NOT a YYYY-MM-DD date — Eventbrite browse pages only support predefined ranges."
                    },
                    "format": {
                        "title": "Event format",
                        "enum": [
                            "",
                            "class",
                            "conference",
                            "festival",
                            "performance",
                            "screening",
                            "seminar",
                            "tournament",
                            "convention",
                            "expo",
                            "game",
                            "party",
                            "rally",
                            "tour",
                            "race",
                            "attraction",
                            "camp-trip-or-retreat",
                            "dinner-or-gala",
                            "networking",
                            "appearance-or-signing",
                            "other"
                        ],
                        "type": "string",
                        "description": "Event format filter (e.g., 'conference', 'festival', 'class', 'networking'). Combined with category and location filters. Leave empty to include all formats. NOT an online-only flag — use the 'onlineOnly' boolean for that."
                    },
                    "priceFilter": {
                        "title": "Price filter",
                        "enum": [
                            "",
                            "free",
                            "paid"
                        ],
                        "type": "string",
                        "description": "Filter by free or paid events only. Leave empty to include both. NOT a numeric price range — Eventbrite browse pages do not support arbitrary price ranges."
                    },
                    "onlineOnly": {
                        "title": "Online events only",
                        "type": "boolean",
                        "description": "Restrict results to virtual/online events. When true, location is ignored. Defaults to false (both in-person and online included).",
                        "default": false
                    },
                    "startUrls": {
                        "title": "Start URLs (advanced)",
                        "type": "array",
                        "description": "Direct Eventbrite browse URLs or event page URLs to scrape. Use this for custom search filters not exposed by this Actor's inputs, or to scrape specific event detail pages. Any URL parameters are preserved (e.g., '?page=2'). Mutually exclusive with searchQuery and location — provide either startUrls OR the filter inputs, not both.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of events to return. Eventbrite browse pages return 20 events per page with up to 49 pages per query (~1,000 events max per filter combination). Default 50 keeps run cost low for typical agent calls. Set higher for bulk extraction.",
                        "default": 50
                    },
                    "includeDetails": {
                        "title": "Include detail-page enrichment",
                        "type": "boolean",
                        "description": "Fetch each event's detail page to extract full description, organizer name and profile URL, ticket tiers with prices, and structured pricing currency. When false, returns only browse-page fields (still 25+ fields). Adds one HTTP request per event but no extra event charge.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Defaults to RESIDENTIAL group for reliability against Cloudflare image CDN. Datacenter works for low-volume runs but may get rate-limited at scale.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
