# Eventbrite \[Only $0.99] Scraper (`memo23/eventbrite-scraper`) Actor

Turn Eventbrite into an events feed AND an organizer lead list: event name, dates, venue, geo, ticket price range and category, plus each organizer’s website, socials, followers and a best-effort email. Any search, event or organizer URL in. One row per event, JSON or CSV out.

- **URL**: https://apify.com/memo23/eventbrite-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Lead generation, AI, Agents
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 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 + Lu.ma + Meetup Events Scraper

**Three event platforms, one scraper.** Pull structured events from any **Eventbrite**, **Lu.ma**, or **Meetup** URL — name, description, start/end dates, venue + address + real lat/long, price, attendance mode, and the organizer/host/group behind each event (incl. **website, social links, and best-effort contact email** on Eventbrite & Lu.ma). Each row carries a `source` field (`eventbrite`, `luma`, or `meetup`) so you can keep all three in one dataset or split them. One row per event, JSON or CSV out, billed per result.

#### How it works

![How Eventbrite Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-eventbrite.png)

#### ✨ Why use this scraper?

Building an events feed? Prospecting event organizers for sponsorship, venues, or services? Tracking ticket prices across a city or category? Most Eventbrite scrapers stop at the event. This one also turns every organizer into a **lead**.

- 🎯 **Three starting points.** Paste an Eventbrite search URL (`/d/{location}/{category}/`), a direct event URL (`/e/...-tickets-{id}`), or an organizer URL (`/o/...`) — all classified automatically. Or just set **location + category + keyword** and let the actor build the search.
- 📋 **JSON-LD–backed accuracy.** Name, dates, venue, address, price and organizer all come from the page's `application/ld+json` block — the same structured data Google reads.
- 💰 **Ticket price range, not guesses.** Each row carries `priceMin`, `priceMax`, `currency`, `isFree`, `ticketAvailability`, and the on-sale window (`saleStart` / `saleEnd`).
- 📍 **Venue + real coordinates.** Venue name, full street address, postcode, and `latitude` / `longitude` for in-person events (online events are flagged `isOnline: true`).
- 📧 **Organizer lead-gen — the differentiator.** For each unique organizer the actor adds `organizerWebsite`, `organizerDomain`, `organizerSocials`, `organizerFollowers`, and a best-effort `organizerEmail` harvested from the organizer's own website. Turn an events list into an outreach list.
- 🔁 **Monitoring mode.** Run on a schedule and get only NEW events each time — the actor keeps a private per-user record of what it already delivered.
- 🧰 **No anti-bot, no auth.** Straight HTML over a parallel impit stack. Search pages paginate via `?page=N` and the actor walks them automatically up to your `maxItems`.
- 📤 **Clean exports.** One row per event with organizer fields merged inline — no duplicate rows. JSON + CSV.

#### 🎯 Use cases

| Team | What they build |
|------|-----------------|
| **Event marketers / sponsorship sales** | Outreach lists of organizers (website + email) running events in a category or city |
| **Venues, caterers, A/V, ticketing vendors** | Lead lists of nearby organizers with upcoming events |
| **Event aggregators / city guides** | Always-fresh event feeds by location + category, with venue, price, and dates |
| **Market & pricing research** | Ticket-price benchmarks across a category, city, or date range |
| **Competitive intelligence** | Track a competitor organizer's events, cadence, pricing, and follower growth |
| **Data journalists / researchers** | Datasets on local event activity, pricing, and organizer reach |

#### 📥 Supported inputs

Pass any mix of URLs in `startUrls` — each is classified automatically. Leave `startUrls` empty to build a search from the convenience fields.

| URL pattern | Source | Behaviour |
|---|---|---|
| `https://www.eventbrite.com/d/{location}/{category}/` | Eventbrite | **Search / listing** — walks every result page (`?page=N`) collecting events |
| `https://www.eventbrite.com/e/{slug}-tickets-{id}` | Eventbrite | **Event detail** — routed straight to the parser |
| `https://www.eventbrite.com/o/{slug}-{id}` | Eventbrite | **Organizer** — used to enrich events from that organizer |
| `https://luma.com/{slug}` | Lu.ma | **Event detail** — auto-detected (Lu.ma event pages and city pages share this shape) |
| `https://luma.com/{city}` or a calendar page | Lu.ma | **Listing** — collects the events on the page |
| `https://www.meetup.com/{group}/events/{id}` | Meetup | **Event detail** — routed straight to the parser |
| `https://www.meetup.com/find/?source=EVENTS&keywords=...` or `/{group}/events/` | Meetup | **Listing** — collects the events on the page |
| *location + category + keyword + onlineOnly* | Eventbrite | The actor builds `https://www.eventbrite.com/d/{location}/{category}/?q={keyword}` for you |

URLs are routed by host — Eventbrite → JSON-LD parser, Lu.ma → Next.js app-data parser, Meetup → Apollo-state parser. All three share the core event + organizer columns; each adds a few source-specific fields:
- **Eventbrite**: `saleStart`/`saleEnd`, `organizerFollowers`, `organizerEmail` (harvested).
- **Lu.ma**: `guestCount`, `requiresApproval`, `spotsRemaining`, `hostName`, `timezone`, `organizerEmail` (harvested).
- **Meetup**: `going`, `waitlist`, `maxTickets`, `groupMembers`, `groupUrlname`, `hostNames`, `topics`. (No email lead-gen — Meetup groups are a closed community.)

Easiest workflow: run a search on eventbrite.com in your browser (pick a city, category, date, online/in-person, price), copy the URL from the address bar, paste it into `startUrls`.

**Not supported:** authenticated/attendee data, hosts outside `eventbrite.*`.

#### 🔄 How it works

1. **Classify each `startUrl`** as a search, event, or organizer URL (or build a search from `location` + `category` + `keyword`).
2. **Walk each search page** (`?page=N`) collecting event links — ~20 events per page — until `maxItems` is reached.
3. **Fetch each event detail page** in parallel via a global sliding window.
4. **Parse the Event JSON-LD** for name, dates, venue, full address + geo, ticket price range, availability, organizer, status, and attendance mode.
5. **Enrich each unique organizer** (when `enrichOrganizer: true`) by fetching `/o/{slug}-{id}` once for website, socials, description, and follower count — cached per organizer.
6. **Harvest a contact email** (when `harvestOrganizerEmails: true`) from the organizer's website (homepage + `/contact` + `/about`), best-effort.
7. **Push one merged row per event** to the dataset.

#### ⚙️ Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | `["https://www.eventbrite.com/d/ny--new-york/all-events/"]` | Eventbrite search, event, and/or organizer URLs. Mix freely. |
| `location` | string | — | Location slug (e.g. `ny--new-york`, `london`, `online`). Used only when `startUrls` is empty. |
| `category` | string | `all-events` | Category slug (e.g. `music--events`, `business--events`). Used only when `startUrls` is empty. |
| `keyword` | string | — | Free-text keyword (`?q=`). Used only when `startUrls` is empty. |
| `onlineOnly` | boolean | `false` | Restrict the built search to online events. |
| `enrichOrganizer` | boolean | `true` | Fetch each unique organizer profile for `organizerWebsite`, `organizerDomain`, `organizerSocials`, `organizerFollowers`. |
| `harvestOrganizerEmails` | boolean | `true` | Best-effort: extract `organizerEmail` from the organizer's website. Requires `enrichOrganizer`. |
| `monitoringMode` | boolean | `false` | Only return events not delivered to you on a previous run. The first run seeds the baseline. |
| `resetMonitoringState` | boolean | `false` | One-shot: clear the saved "events seen" record at run start. |
| `maxItems` | integer | `1000` | Hard cap on events collected (controls billing). |
| `maxConcurrency` / `minConcurrency` | integer | `10` / `1` | Parallel HTTP request limits. |
| `proxy` | object | Apify residential | Apify proxy configuration. Eventbrite has no aggressive anti-bot. |

#### 📊 Output overview

Each scraped event is one **single dataset row** of `type: "event"`. When `enrichOrganizer` is `true`, the organizer's website, domain, socials, followers, and harvested email are merged into the same row — no separate organizer rows, so the dataset row count equals the event count exactly.

#### 📦 Output sample

One merged row per event:

```json
{
    "type": "event",
    "eventId": "1984643225312",
    "eventUrl": "https://www.eventbrite.com/e/the-2026-gracies-luncheon-tickets-1984643225312",
    "name": "The 2026 Gracies Luncheon",
    "description": "The Gracie Awards recognize exemplary programming created by women, for women and about women in all facets of media and entertainment.",
    "image": "https://img.evbuc.com/...original.20250325-142036?...",
    "startDate": "2026-06-16T11:00:00-04:00",
    "endDate": "2026-06-16T14:00:00-04:00",
    "timezoneOffset": "-04:00",
    "isOnline": false,
    "attendanceMode": "OfflineEventAttendanceMode",
    "status": "EventScheduled",
    "language": "en-US",
    "venueName": "Cipriani 42nd Street",
    "streetAddress": "110 East 42nd Street, New York, NY 10017",
    "addressLocality": "New York",
    "addressRegion": "NY",
    "postalCode": "10017",
    "country": "US",
    "latitude": 40.7515845,
    "longitude": -73.9771076,
    "priceMin": 215.26,
    "priceMax": 482.02,
    "currency": "USD",
    "isFree": false,
    "ticketAvailability": "InStock",
    "saleStart": "2026-03-20T04:00:00Z",
    "saleEnd": "2026-06-18T16:30:00Z",
    "category": "Business",
    "organizerName": "Alliance for Women in Media",
    "organizerUrl": "https://www.eventbrite.com/o/alliance-for-women-in-media-53663754033",
    "organizerId": "53663754033",
    "organizerWebsite": "https://allwomeninmedia.org/",
    "organizerDomain": "allwomeninmedia.org",
    "organizerDescription": null,
    "organizerSocials": [],
    "organizerFollowers": 75,
    "organizerEmail": "info@allwomeninmedia.org",
    "scrapedAt": "2026-06-10T14:48:58.354Z"
}
````

#### 🗂 Key output fields

| Group | Fields |
|---|---|
| **Identifiers** | `type`, `eventId`, `eventUrl`, `scrapedAt` |
| **Event** | `name`, `description`, `image`, `category`, `status`, `language` |
| **Schedule** | `startDate`, `endDate` (ISO with offset), `timezoneOffset` |
| **Format** | `isOnline`, `attendanceMode` (`OfflineEventAttendanceMode` / `OnlineEventAttendanceMode` / `MixedEventAttendanceMode`) |
| **Venue** | `venueName`, `streetAddress`, `addressLocality`, `addressRegion`, `postalCode`, `country`, `latitude`, `longitude` *(null for online events)* |
| **Tickets** | `priceMin`, `priceMax`, `currency`, `isFree`, `ticketAvailability`, `saleStart`, `saleEnd` |
| **Organizer (lead-gen, merged when `enrichOrganizer: true`)** | `organizerName`, `organizerUrl`, `organizerId`, `organizerWebsite`, `organizerDomain`, `organizerSocials[]`, `organizerFollowers`, `organizerDescription`, `organizerEmail` |

#### ❓ FAQ

**Which Eventbrite URLs are supported?**
Search/listing URLs (`/d/{location}/{category}/`), event URLs (`/e/...-tickets-{id}`), and organizer URLs (`/o/...`). You can also skip URLs entirely and set `location` + `category` + `keyword`.

**Why is `organizerEmail` sometimes `null`?**
Eventbrite does not publish organizer emails. The actor finds the organizer's own website (when they've linked one), then best-effort extracts a public contact email from it (homepage / contact / about pages). If the organizer hasn't linked a website, or their site doesn't expose an email, the field is `null` — that's expected, not an error. In practice business/professional organizers convert far better than free-party organizers.

**Why are some venue/address/geo fields `null`?**
Those are online events (`isOnline: true`) — there's no physical venue. In-person events carry the full venue, address, postcode, and coordinates.

**Does it paginate?**
Yes — search pages paginate via `?page=N` and the actor walks them automatically until `maxItems` is reached.

**How does monitoring mode work?**
With `monitoringMode: true`, events whose ID was already delivered to you on a previous run are skipped (no fetch, no charge). The first run seeds your baseline; later runs return only new events. Pair it with Apify's scheduler for an "events added since last run" feed.

**Can I scrape private or attendee data?**
No. The scraper accesses only publicly available event and organizer pages — no logged-in content, no attendee/ticket-buyer data.

**How do I limit results?**
Set `maxItems`. The actor stops queuing new events as soon as the cap is reached.

#### 💬 Support

- For issues or feature requests, please use the **Issues** tab on the actor's Apify Console page.
- Author's website: <https://muhamed-didovic.github.io/>
- Email: <muhamed.didovic@gmail.com>

#### 🛠 Additional services

- Custom output shape, extra fields, or one-off datasets: <muhamed.didovic@gmail.com>
- Need a similar scraper for other event or ticketing sites (Meetup, Lu.ma, Ticketmaster, etc.)? Drop an email.
- For API access (no Apify fee, just a usage fee for the API): <muhamed.didovic@gmail.com>

#### 🔎 Explore more scrapers

If this Eventbrite Scraper was useful, see other scrapers and actors at [memo23's Apify profile](https://apify.com/memo23) — covering events, job boards, real estate, social media, and more.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Eventbrite, Inc., Lu.ma, Meetup, or any of their subsidiaries or affiliates. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available event and organizer pages on eventbrite.com — no authenticated endpoints, attendee data, or content behind an Eventbrite login. The best-effort organizer email is collected from the organizer's own public website. Users are responsible for ensuring their use complies with Eventbrite's Terms of Service, applicable data-protection law (GDPR, CCPA, etc.), and any contractual obligations of their own organisation, including lawful basis for any outreach to organizers.

***

### SEO Keywords

eventbrite scraper, scrape eventbrite, eventbrite api, eventbrite.com scraper, apify eventbrite, eventbrite event scraper, eventbrite events data, eventbrite organizer scraper, eventbrite organizer emails, event lead generation scraper, event organizer leads, eventbrite ticket price scraper, eventbrite search scraper, scrape events by city, event data api, eventbrite listings export, event marketing leads, eventbrite sponsorship prospecting, eventbrite competitor tracking, event aggregator feed, meetup alternative scraper, luma events scraper alternative

# Actor input Schema

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

Full Eventbrite, Lu.ma, and/or Meetup URLs to crawl. Mix any of them in the same array.

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

Eventbrite location slug used to build a search when no Start URLs are given — e.g. `ny--new-york`, `united-states`, `london`, or `online`. Tip: run a search on eventbrite.com and copy the segment after `/d/`.

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

Eventbrite category to search within (used only when no Start URLs are given).

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

Optional free-text keyword for the built search (becomes `?q=`). Used only when no Start URLs are given.

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

Restrict the built search to online events (sets the location segment to `online`). Used only when no Start URLs are given.

## `enrichOrganizer` (type: `boolean`):

Fetch each unique organizer profile page once to add `organizerWebsite`, `organizerDomain`, `organizerSocials`, `organizerDescription`, and `organizerFollowers`. Adds one HTTP call per unique organizer.

## `harvestOrganizerEmails` (type: `boolean`):

When an organizer website is found, fetch it (homepage + /contact + /about) and extract a contact email into `organizerEmail`. Requires organizer enrichment. The email is `null` when the organizer's website does not expose one — this is normal, not an error.

## `monitoringMode` (type: `boolean`):

When enabled, events whose ID has already been delivered to you are silently skipped (no detail page is fetched, no charge applies for them). The first run after enabling monitoring returns every match — that builds your baseline. Every subsequent run returns only new events.

## `resetMonitoringState` (type: `boolean`):

One-shot toggle: clear the saved 'events already seen' record at the start of this run. Use this when you change search URL or want to rebuild the baseline. Has no effect when monitoring mode is off.

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

Hard cap on the number of events collected across all start URLs. Use this to control billing.

## `maxConcurrency` (type: `integer`):

Maximum number of event pages processed in parallel.

## `minConcurrency` (type: `integer`):

Minimum number of event pages processed in parallel.

## `maxRequestRetries` (type: `integer`):

Number of retries before a failed request is given up.

## `proxy` (type: `object`):

Apify proxy settings. Eventbrite has no aggressive anti-bot, so a small residential pool (or even datacenter) works fine.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.eventbrite.com/d/ny--new-york/all-events/",
    "https://luma.com/sf",
    "https://www.meetup.com/find/?source=EVENTS&keywords=technology"
  ],
  "location": "ny--new-york",
  "category": "all-events",
  "keyword": "tech conference",
  "onlineOnly": false,
  "enrichOrganizer": true,
  "harvestOrganizerEmails": true,
  "monitoringMode": false,
  "resetMonitoringState": false,
  "maxItems": 1000,
  "maxConcurrency": 10,
  "minConcurrency": 1,
  "maxRequestRetries": 5,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        "https://www.eventbrite.com/d/ny--new-york/all-events/",
        "https://luma.com/sf",
        "https://www.meetup.com/find/?source=EVENTS&keywords=technology"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/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 = {
    "startUrls": [
        "https://www.eventbrite.com/d/ny--new-york/all-events/",
        "https://luma.com/sf",
        "https://www.meetup.com/find/?source=EVENTS&keywords=technology",
    ],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/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 '{
  "startUrls": [
    "https://www.eventbrite.com/d/ny--new-york/all-events/",
    "https://luma.com/sf",
    "https://www.meetup.com/find/?source=EVENTS&keywords=technology"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call memo23/eventbrite-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eventbrite [Only $0.99] Scraper",
        "description": "Turn Eventbrite into an events feed AND an organizer lead list: event name, dates, venue, geo, ticket price range and category, plus each organizer’s website, socials, followers and a best-effort email. Any search, event or organizer URL in. One row per event, JSON or CSV out.",
        "version": "0.0",
        "x-build-id": "cgpCUPMDOeGbRebdB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~eventbrite-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-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/memo23~eventbrite-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-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/memo23~eventbrite-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-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": {
                    "startUrls": {
                        "title": "Eventbrite, Lu.ma & Meetup URLs",
                        "type": "array",
                        "description": "Full Eventbrite, Lu.ma, and/or Meetup URLs to crawl. Mix any of them in the same array.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Eventbrite location slug used to build a search when no Start URLs are given — e.g. `ny--new-york`, `united-states`, `london`, or `online`. Tip: run a search on eventbrite.com and copy the segment after `/d/`."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "all-events",
                            "music--events",
                            "business--events",
                            "food-and-drink--events",
                            "community--events",
                            "arts--events",
                            "film-and-media--events",
                            "sports-and-fitness--events",
                            "health--events",
                            "science-and-tech--events",
                            "travel-and-outdoor--events",
                            "charity-and-causes--events",
                            "family-and-education--events",
                            "fashion--events",
                            "hobbies--events",
                            "home-and-lifestyle--events",
                            "spirituality--events"
                        ],
                        "type": "string",
                        "description": "Eventbrite category to search within (used only when no Start URLs are given).",
                        "default": "all-events"
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Optional free-text keyword for the built search (becomes `?q=`). Used only when no Start URLs are given."
                    },
                    "onlineOnly": {
                        "title": "Online events only",
                        "type": "boolean",
                        "description": "Restrict the built search to online events (sets the location segment to `online`). Used only when no Start URLs are given.",
                        "default": false
                    },
                    "enrichOrganizer": {
                        "title": "Enrich organizer (website, socials, description, followers)",
                        "type": "boolean",
                        "description": "Fetch each unique organizer profile page once to add `organizerWebsite`, `organizerDomain`, `organizerSocials`, `organizerDescription`, and `organizerFollowers`. Adds one HTTP call per unique organizer.",
                        "default": true
                    },
                    "harvestOrganizerEmails": {
                        "title": "Harvest organizer contact email (best-effort)",
                        "type": "boolean",
                        "description": "When an organizer website is found, fetch it (homepage + /contact + /about) and extract a contact email into `organizerEmail`. Requires organizer enrichment. The email is `null` when the organizer's website does not expose one — this is normal, not an error.",
                        "default": true
                    },
                    "monitoringMode": {
                        "title": "Monitoring mode (only return events not seen on previous runs)",
                        "type": "boolean",
                        "description": "When enabled, events whose ID has already been delivered to you are silently skipped (no detail page is fetched, no charge applies for them). The first run after enabling monitoring returns every match — that builds your baseline. Every subsequent run returns only new events.",
                        "default": false
                    },
                    "resetMonitoringState": {
                        "title": "Reset monitoring state (one-shot)",
                        "type": "boolean",
                        "description": "One-shot toggle: clear the saved 'events already seen' record at the start of this run. Use this when you change search URL or want to rebuild the baseline. Has no effect when monitoring mode is off.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum events to scrape",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on the number of events collected across all start URLs. Use this to control billing.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of event pages processed in parallel.",
                        "default": 10
                    },
                    "minConcurrency": {
                        "title": "Min concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Minimum number of event pages processed in parallel.",
                        "default": 1
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of retries before a failed request is given up.",
                        "default": 5
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Eventbrite has no aggressive anti-bot, so a small residential pool (or even datacenter) works fine.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
