# Eventbrite Scraper (`solidcode/eventbrite-scraper`) Actor

\[💰 $1.0 / 1K] Extract events from Eventbrite — names, dates, organizers, venues with GPS, ticket prices, images, and tags. Search by country and city, filter by category, date, format, and price, or paste direct event URLs.

- **URL**: https://apify.com/solidcode/eventbrite-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

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

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

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

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

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

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

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


# README

## Eventbrite Scraper

Pull events from Eventbrite at scale — names, dates, organizers, venues with GPS coordinates, ticket pricing, images, and tags. Search by country and city, filter by 27 categories, format, price, and date range, or paste direct event URLs from any Eventbrite domain. Built for event marketers, lead-gen teams, market researchers, ticket resellers, and music and sports promoters who need a clean Eventbrite dataset without writing pagination logic, slug-mapping tables, or recurring-event de-duplication code.

### Why This Scraper?

- **27 official Eventbrite categories** in a single dropdown — Music, Performing Arts, Food & Drink, Business, Sports & Fitness, Charity & Causes, Holiday, plus 20 more — selectable without knowing Eventbrite's internal slug format.
- **31 supported countries with canonical location slugs** — United States, United Kingdom, Germany, France, Japan, Singapore, Brazil, UAE, and 23 more — pre-mapped so you type "London" or "New York" instead of `united-kingdom--london`.
- **Direct event URL mode supports every Eventbrite TLD** — `.com`, `.co.uk`, `.fr`, `.de`, `.com.au`, `.nl`, `.es`, `.it`, `.ca`, `.ie` — paste a list of known events and skip the search step entirely.
- **Independent start and end date bounds** — pass either, both, or neither. Many event scrapers force you to set both or neither; this one treats them as separate filters.
- **Recurring series de-duplicated to a single row** — a weekly yoga class returns 1 row, not 52, with `isSeriesParent: true` and `seriesId` flagged so you can fetch every session separately if you need the full schedule.
- **Latitude and longitude on every venue** — geographic analysis, mapping, or radius search without a separate geocoding step or a Google Maps API key.
- **Online-only filter** — toggle a single dropdown to ignore physical venues entirely and pull Eventbrite's global digital catalog. Country and city become irrelevant in this mode.
- **Free vs. paid event filter applied at the URL level** — distinct from category, so you can isolate ticketed events for revenue analysis or free events for community outreach in one run.
- **980-event server cap fully supported** — pagination tested through the entire 49-page set Eventbrite returns per search, with no duplicates and no skipped pages.

### Use Cases

**Event Marketing & Promotion**
- Build a calendar of competing events in your city to time your launches
- Track conferences and meetups by category for sponsorship outreach
- Identify high-traffic venues hosting your audience's events

**Lead Generation & Sales**
- Extract organizer profiles with follower counts and event histories for B2B outreach
- Build a target list of paid-event organizers in a vertical (Business, Health, Tech) for partnership pitches
- Surface organizer URLs and social handles for relationship mapping

**Market & Industry Research**
- Quantify the volume of Music vs. Food & Drink events across major metros
- Track week-over-week event creation rates as a leading indicator of local recovery or growth
- Compare paid-event price ranges (priceMin/priceMax) by category to benchmark market rates

**Sponsorship & Brand Discovery**
- Find sponsored events in Charity & Causes, Sports & Fitness, or Family & Education for activation matching
- Surface recurring series with high attendance signals for season-long sponsorship
- Pull organizer follower counts to size audience reach before outreach

**Concert, Festival & Ticket Tracking**
- Monitor Music and Nightlife events daily for resale opportunity identification
- Track sold-out status and price floors across markets
- Surface tour-style recurring series and capture every tour-stop date as a single row

**Travel & Hospitality Planning**
- Pull Holiday, Seasonal, and Travel & Outdoor events in a destination city to build "things to do" content
- Match event peaks to hotel and short-let pricing for revenue management
- Generate calendars of festival weekends across 31 countries

**Academic & Civic Research**
- Track Government & Politics, Religion & Spirituality, or Community events for civic engagement studies
- Build datasets of School Activities and Family & Education events for ed-tech research
- Quantify online vs. in-person event distribution across regions and over time

### Getting Started

#### Search by City

The simplest run — every Eventbrite event in New York, capped at 100 results:

```json
{
    "country": "united-states",
    "city": "New York",
    "maxResults": 100
}
````

#### Category + Date Range

Music events in Berlin happening this summer:

```json
{
    "country": "germany",
    "city": "Berlin",
    "category": "music",
    "startDate": "2026-06-01",
    "endDate": "2026-08-31",
    "maxResults": 200
}
```

#### Online-Only, Free, with a Keyword

Free online startup workshops, no city or country needed:

```json
{
    "eventFormat": "online",
    "priceFilter": "free",
    "keyword": "startup",
    "maxResults": 100
}
```

#### Direct Event URLs (multi-domain)

Paste a list of known Eventbrite URLs from any country's TLD — the scraper goes straight to the detail page and ignores all search filters:

```json
{
    "eventUrls": [
        "https://www.eventbrite.com/e/your-event-tickets-12345",
        "https://www.eventbrite.co.uk/e/london-jazz-night-tickets-67890",
        "https://www.eventbrite.fr/e/concert-paris-tickets-13579",
        "https://www.eventbrite.com.au/e/sydney-startup-meetup-tickets-24680"
    ]
}
```

### Input Reference

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `eventUrls` | string\[] | `[]` | Direct Eventbrite event URLs from any TLD (`.com`, `.co.uk`, `.fr`, `.de`, `.com.au`, etc.). When provided, all search filters below are ignored. |
| `country` | select | `United States` | Country to search in. 31 options. Ignored when `eventUrls` are provided or `eventFormat` is `Online only`. |
| `city` | string | `New York` | City to search in. Common abbreviations supported (`NYC`, `LA`, `SF`, `DC`) — case-insensitive, hyphens or spaces both work. Use the canonical city name for non-US locations. Ignored in URL mode or online-only mode. |
| `category` | select | `Any category` | One of 27 official Eventbrite categories — Music, Performing Arts, Food & Drink, Business, Health, Sports & Fitness, Charity & Causes, Holiday, and 19 others. |
| `keyword` | string | `""` | Free-text keyword (e.g., "jazz", "startup", "yoga"). Combine with category or use on its own. |
| `startDate` | date | `null` | Earliest event start date in YYYY-MM-DD. Works independently of `endDate`. |
| `endDate` | date | `null` | Latest event start date in YYYY-MM-DD. Works independently of `startDate`. |
| `eventFormat` | select | `In-person and online` | `In-person only`, `Online only`, or both. Online-only mode overrides country and city. |
| `priceFilter` | select | `Free and paid` | `Free only`, `Paid only`, or both. When combined with a category, category wins on the URL and price is applied client-side. |
| `maxResults` | integer | `100` | Maximum events per search. Eventbrite caps a single search at 980 events (49 pages × 20). Set to `0` for the full available set, up to a defensive ceiling of 100,000 events per run. |

### Output

One row per event. Recurring series collapse to a single row with all session dates in the `dates[]` array. Online events return `venue: null`.

```json
{
    "id": "1234567890",
    "name": "Summer Jazz Night at The Blue Note",
    "url": "https://www.eventbrite.com/e/summer-jazz-night-tickets-1234567890",
    "summary": "An intimate evening of live jazz featuring local and touring artists.",
    "description": "Doors open at 7 PM. Two sets, full bar, table seating...",
    "startDate": "2026-07-12T19:00:00-04:00",
    "endDate": "2026-07-12T22:30:00-04:00",
    "timezone": "America/New_York",
    "isOnline": false,
    "isCancelled": false,
    "status": "live",
    "language": "en_US",
    "category": "Music",
    "subcategory": "Jazz",
    "tags": ["live music", "nightlife", "manhattan"],
    "isFree": false,
    "isSoldOut": false,
    "priceMin": 25.00,
    "priceMax": 65.00,
    "currency": "USD",
    "salesStatus": "on_sale",
    "ticketsUrl": "https://www.eventbrite.com/e/summer-jazz-night-tickets-1234567890",
    "venue": {
        "name": "The Blue Note",
        "address1": "131 W 3rd St",
        "address2": null,
        "city": "New York",
        "region": "NY",
        "postalCode": "10012",
        "country": "US",
        "latitude": 40.7305,
        "longitude": -74.0009
    },
    "organizer": {
        "id": "987654321",
        "name": "Blue Note Presents",
        "url": "https://www.eventbrite.com/o/blue-note-presents-987654321",
        "summary": "Booking and producing live jazz events in NYC since 2008.",
        "websiteUrl": "https://bluenotepresents.com",
        "twitter": "bluenotepresents",
        "facebook": "bluenotepresents",
        "numFollowers": 15420,
        "numUpcomingEvents": 47
    },
    "images": [
        "https://img.evbuc.com/.../original.jpg",
        "https://img.evbuc.com/.../large.jpg"
    ],
    "seriesId": null,
    "isSeriesParent": false,
    "numChildren": null,
    "dates": [
        { "startDate": "2026-07-12T19:00:00-04:00", "endDate": "2026-07-12T22:30:00-04:00" }
    ],
    "sourceUrl": "https://www.eventbrite.com/d/united-states--new-york/music/"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Eventbrite event ID |
| `name` | string | Event title |
| `url` | string | Canonical event detail URL |
| `summary` | string | Short text description shown on the event card |
| `description` | string | Full long-form event description |
| `startDate` | string | ISO 8601 with timezone offset |
| `endDate` | string | ISO 8601 with timezone offset |
| `timezone` | string | IANA timezone name (e.g., `America/New_York`) |
| `isOnline` | boolean | True for digital-only events |
| `isCancelled` | boolean | True if the event was cancelled |
| `status` | string | Eventbrite lifecycle state (`live`, `started`, `completed`, etc.) |
| `language` | string | Event listing language code |
| `category` | string | Display category name (e.g., `Music`) |
| `subcategory` | string | Eventbrite sub-genre when present |
| `tags` | string\[] | Free-text tags applied by the organizer |
| `images` | string\[] | Hero and gallery image URLs |
| `sourceUrl` | string | The search URL or input URL that produced this row |

#### Pricing & Tickets

| Field | Type | Description |
|-------|------|-------------|
| `isFree` | boolean | null | `true` when at least one free ticket type exists; `null` when ticket info is unavailable |
| `isSoldOut` | boolean | null | `true` when no tickets remain available; `null` when ticket info is unavailable |
| `priceMin` | number | null | Lowest current ticket price; `null` for free or unticketed events |
| `priceMax` | number | null | Highest current ticket price; `null` for free or unticketed events |
| `currency` | string | ISO 4217 currency code |
| `salesStatus` | string | Ticketing state (`on_sale`, `not_yet_on_sale`, `sales_ended`, `sold_out`) |
| `ticketsUrl` | string | Direct ticket-purchase URL |

#### Venue

Returns `null` for online-only events.

| Field | Type | Description |
|-------|------|-------------|
| `venue.name` | string | Venue display name |
| `venue.address1` | string | Street address line 1 |
| `venue.address2` | string | Street address line 2 |
| `venue.city` | string | City |
| `venue.region` | string | State or region code |
| `venue.postalCode` | string | Postal code |
| `venue.country` | string | Country code |
| `venue.latitude` | number | Decimal latitude |
| `venue.longitude` | number | Decimal longitude |

#### Organizer

| Field | Type | Description |
|-------|------|-------------|
| `organizer.id` | string | Organizer ID |
| `organizer.name` | string | Organizer display name |
| `organizer.url` | string | Eventbrite organizer page |
| `organizer.summary` | string | Short bio shown on the event page |
| `organizer.websiteUrl` | string | External website |
| `organizer.twitter` | string | Twitter handle |
| `organizer.facebook` | string | Facebook handle |
| `organizer.numFollowers` | number | Eventbrite follower count |
| `organizer.numUpcomingEvents` | number | Future events on this organizer's profile |

#### Recurring Series

A recurring event (a weekly class, a multi-day festival) is collapsed into a single parent row instead of fanning out as 52 duplicates. The fields below tell you whether the row represents a series parent — and let you go fetch the full session schedule from the Eventbrite API if you need it.

| Field | Type | Description |
|-------|------|-------------|
| `seriesId` | string | null | Parent series ID when the event is part of a recurring series; `null` otherwise |
| `isSeriesParent` | boolean | `true` when this row is the parent of a recurring series with at least one child session |
| `numChildren` | number | null | Total number of sessions in the recurring series; `null` for non-recurring events |
| `dates` | object\[] | The parent event's `{startDate, endDate}`. Always length 1 — additional sessions are not expanded |

### Tips for Best Results

- **Always pair country with city.** Eventbrite's URL structure is `country--city`, so a city alone returns nothing. Pick the country first, then type the city.
- **For non-US cities, use the full country name slug** — `united-kingdom`, not `uk`. The country dropdown shows you the exact slug for all 31 supported countries.
- **Combine category and price filter knowingly.** Eventbrite's URL only carries one filter at a time. When you set both, category wins on the URL and the price filter is applied client-side after the fetch — slightly slower, still accurate.
- **Date bounds are independent.** Set `startDate` alone for a future-only window, `endDate` alone for a "before this date" cutoff, or both for a tight range. No need to fill the other to make one work.
- **Direct URL mode is the fastest path for known events.** Skip search entirely by pasting URLs into `eventUrls` — no pagination, no slug mapping, full detail in one shot. Mix TLDs freely.
- **The 980-event ceiling is per-search, not per-run.** To go beyond, split a broad search into narrower ones — by month using `startDate`/`endDate`, or by category. Each narrower search gets its own 980-event budget.
- **Use online-only mode for global digital catalogs.** When `eventFormat` is `Online only`, country and city are ignored — Eventbrite serves a worldwide online catalog, with results biased toward the locale of the requesting connection. For the broadest pool, set `Country` to a major market (United States or United Kingdom) and let the actor follow.

### Pricing

**$1.00 per 1,000 results.** No compute charges — you only pay per result returned.

| Results | Estimated Cost |
|---------|----------------|
| 100 | $0.10 |
| 1,000 | $1.00 |
| 10,000 | $10.00 |
| 100,000 | $100.00 |

A "result" is any event row in the output dataset. Recurring series count as one result regardless of how many session dates are embedded in the `dates[]` array. Platform storage and bandwidth fees from your Apify plan are not included in this rate.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new events
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate event marketing, market research, lead generation, and analytics. Users are responsible for complying with applicable laws and Eventbrite's Terms of Service, including respecting rate limits and content usage rules. Only public event listings are extracted — no private, gated, or password-protected event data is accessed. Attribution to Eventbrite is recommended when republishing event data. Do not use extracted data for spam, harassment, or any illegal purpose.

# Actor input Schema

## `eventUrls` (type: `array`):

Direct Eventbrite event URLs (e.g., 'https://www.eventbrite.com/e/example-event-tickets-12345'). When provided, the search filters below are ignored — the actor goes straight to the event detail page. Leave empty to search by country and city instead.

## `country` (type: `string`):

Country to search in. Ignored when Event URLs are provided, or when Event Format is set to 'Online only'.

## `city` (type: `string`):

City to search in (e.g., 'New York', 'London', 'Berlin'). Common abbreviations are recognised (NYC, LA, SF, DC). Ignored when Event URLs are provided, or when Event Format is set to 'Online only'.

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

Event category to filter by. Pick 'Any category' to ignore. Note: category and price filter are mutually exclusive on Eventbrite — when both are set, category wins and price is applied client-side after the fetch.

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

Free-text keyword for the search (e.g., 'jazz', 'startup', 'yoga'). Combine with category or use on its own to find events by name or description.

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

Earliest event start date in YYYY-MM-DD format. Leave empty for no lower bound. Works on its own — you do not need to also set an End Date.

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

Latest event start date in YYYY-MM-DD format. Leave empty for no upper bound. Works on its own — you do not need to also set a Start Date.

## `eventFormat` (type: `string`):

Show in-person events, online events, or both. Selecting 'Online only' overrides Country and City — Eventbrite's online catalog is global.

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

Show free events, paid events, or both. Note: when a Category is also chosen, Eventbrite's URL structure forces a choice — category wins and the price filter is applied client-side after the fetch.

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

Maximum number of events to return per search. Eventbrite caps a single search at ~980 events (49 pages × 20). Use 0 for the full available set (up to a defensive ceiling of 100,000 events per run).

## Actor input object example

```json
{
  "eventUrls": [],
  "country": "united-states",
  "city": "new-york",
  "category": "any",
  "eventFormat": "any",
  "priceFilter": "any",
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of events with key fields: name, start date, organizer, venue, and price.

## `details` (type: `string`):

Full per-event detail rows including organizer, venue with GPS, all images, ticket pricing, and tags.

# 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 = {
    "eventUrls": [],
    "country": "united-states",
    "city": "new-york",
    "category": "any",
    "keyword": "",
    "startDate": "",
    "endDate": "",
    "eventFormat": "any",
    "priceFilter": "any",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/eventbrite-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "eventUrls": [],
    "country": "united-states",
    "city": "new-york",
    "category": "any",
    "keyword": "",
    "startDate": "",
    "endDate": "",
    "eventFormat": "any",
    "priceFilter": "any",
    "maxResults": 100,
}

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

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

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

```

## CLI example

```bash
echo '{
  "eventUrls": [],
  "country": "united-states",
  "city": "new-york",
  "category": "any",
  "keyword": "",
  "startDate": "",
  "endDate": "",
  "eventFormat": "any",
  "priceFilter": "any",
  "maxResults": 100
}' |
apify call solidcode/eventbrite-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eventbrite Scraper",
        "description": "[💰 $1.0 / 1K] Extract events from Eventbrite — names, dates, organizers, venues with GPS, ticket prices, images, and tags. Search by country and city, filter by category, date, format, and price, or paste direct event URLs.",
        "version": "1.0",
        "x-build-id": "34cAGrbPggbzyWg8a"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~eventbrite-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-eventbrite-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solidcode~eventbrite-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-eventbrite-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solidcode~eventbrite-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-eventbrite-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "eventUrls": {
                        "title": "Event URLs",
                        "type": "array",
                        "description": "Direct Eventbrite event URLs (e.g., 'https://www.eventbrite.com/e/example-event-tickets-12345'). When provided, the search filters below are ignored — the actor goes straight to the event detail page. Leave empty to search by country and city instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "united-states",
                            "united-kingdom",
                            "canada",
                            "australia",
                            "ireland",
                            "new-zealand",
                            "germany",
                            "france",
                            "spain",
                            "italy",
                            "netherlands",
                            "belgium",
                            "portugal",
                            "switzerland",
                            "austria",
                            "sweden",
                            "norway",
                            "denmark",
                            "finland",
                            "poland",
                            "japan",
                            "singapore",
                            "hong-kong",
                            "india",
                            "philippines",
                            "brazil",
                            "mexico",
                            "argentina",
                            "chile",
                            "colombia",
                            "south-africa",
                            "united-arab-emirates"
                        ],
                        "type": "string",
                        "description": "Country to search in. Ignored when Event URLs are provided, or when Event Format is set to 'Online only'.",
                        "default": "united-states"
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City to search in (e.g., 'New York', 'London', 'Berlin'). Common abbreviations are recognised (NYC, LA, SF, DC). Ignored when Event URLs are provided, or when Event Format is set to 'Online only'."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "any",
                            "music",
                            "nightlife",
                            "performing-arts",
                            "visual-arts",
                            "film-and-media",
                            "food-and-drink",
                            "business",
                            "health",
                            "science-and-tech",
                            "sports-and-fitness",
                            "fitness-and-wellness",
                            "travel-and-outdoor",
                            "charity-and-causes",
                            "religion-and-spirituality",
                            "family-and-education",
                            "school-activities",
                            "holiday",
                            "seasonal",
                            "hobbies",
                            "hobbies-and-special-interest",
                            "community",
                            "government-and-politics",
                            "fashion",
                            "auto-boat-and-air",
                            "home-and-lifestyle",
                            "other"
                        ],
                        "type": "string",
                        "description": "Event category to filter by. Pick 'Any category' to ignore. Note: category and price filter are mutually exclusive on Eventbrite — when both are set, category wins and price is applied client-side after the fetch.",
                        "default": "any"
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Free-text keyword for the search (e.g., 'jazz', 'startup', 'yoga'). Combine with category or use on its own to find events by name or description."
                    },
                    "startDate": {
                        "title": "Start Date",
                        "type": "string",
                        "description": "Earliest event start date in YYYY-MM-DD format. Leave empty for no lower bound. Works on its own — you do not need to also set an End Date."
                    },
                    "endDate": {
                        "title": "End Date",
                        "type": "string",
                        "description": "Latest event start date in YYYY-MM-DD format. Leave empty for no upper bound. Works on its own — you do not need to also set a Start Date."
                    },
                    "eventFormat": {
                        "title": "Event Format",
                        "enum": [
                            "any",
                            "in-person",
                            "online"
                        ],
                        "type": "string",
                        "description": "Show in-person events, online events, or both. Selecting 'Online only' overrides Country and City — Eventbrite's online catalog is global.",
                        "default": "any"
                    },
                    "priceFilter": {
                        "title": "Price",
                        "enum": [
                            "any",
                            "free",
                            "paid"
                        ],
                        "type": "string",
                        "description": "Show free events, paid events, or both. Note: when a Category is also chosen, Eventbrite's URL structure forces a choice — category wins and the price filter is applied client-side after the fetch.",
                        "default": "any"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of events to return per search. Eventbrite caps a single search at ~980 events (49 pages × 20). Use 0 for the full available set (up to a defensive ceiling of 100,000 events per run).",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
