# Eventbrite Scraper - Extract Events by City & Category (`techforce.global/eventbrite-scraper`) Actor

Scrape Eventbrite events by city and category, no login or API key required. Extract event name, date, venue, price, organizer, and images as clean JSON, CSV, or Excel. Filter by date range, free-only, or online-only, and auto-deliver results to Notion, Slack, and Airtable.

- **URL**: https://apify.com/techforce.global/eventbrite-scraper.md
- **Developed by:** [Techforce Global](https://apify.com/techforce.global) (community)
- **Categories:** Travel, Agents, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### Eventbrite Scraper & MCP Connector

Scrape **public Eventbrite events by city and category** — event details, dates, venues, prices, organizers, and images, all as structured JSON. **No API key, no login, no manual copy-pasting from listing pages.**

Built for event marketers, community managers, researchers, and developers who need a clean feed of what's happening in a city — in seconds, not an afternoon of browsing Eventbrite.

> **Pick a city and category → get every matching event → deliver it straight into Notion, Slack, Google Sheets, or your CRM.**

---

### ⭐ Why This Actor?

- ✅ **Just pick a city and category** — use Eventbrite's own `country--city` slug (e.g. `india--ahmedabad`) and any of 18 built-in categories
- ✅ **No token, no login** — the Actor pulls a session token straight from Eventbrite's public browse page, the same way a browser does
- ✅ **Filter as you scrape** — date range, free-only, and online-only filters cut out events you don't need before they hit your dataset
- ✅ **Automatic pagination** — keeps paging through results until it hits your `maxEvents` limit or runs out of events
- ✅ **Configurable output fields** — turn description, organizer info, and images on only when you need them, to keep runs fast and datasets lean
- ✅ **Polite by design** — small delays between pages and retry-with-backoff on rate limits, so runs don't get blocked mid-way
- ✅ **Deliver anywhere via MCP connectors** — push scraped events straight into Notion, Slack, Google Sheets, Airtable, Jira, and more
- ✅ **Export-ready** — JSON, CSV, Excel, or direct API integration for your own pipeline

---

### 📝 Use Cases & ROI

| Use Case | Time Saved | What You Get |
| --- | --- | --- |
| **Local event marketing** | 1–3 hrs/city | A ready feed of what's on, to cross-promote or curate |
| **Community & city guides** | 2–4 hrs/batch | Structured listings for newsletters, apps, or websites |
| **Competitor & market research** | 1–2 hrs/category | What organizers in a category/city are running, and at what price |
| **Lead generation for organizers** | 2–5 hrs/batch | Organizer names and links to reach out to for partnerships |
| **Data feeds & dashboards** | 1–3 hrs/setup | Clean JSON/CSV ready to load into a sheet, database, or BI tool |

---

### 🚀 How to Use

1. Open the Actor on Apify.
2. Set **Location** using Eventbrite's slug format (e.g. `india--ahmedabad`, `united-states--new-york`).
3. Pick a **Category** from the dropdown (default: All Events).
4. Set **Max events** to cap how many results to collect (default: 100).
5. _(Optional)_ Narrow results with **Start/End date**, **Free events only**, or **Online events only**.
6. _(Optional)_ Toggle which **output fields** to include — name, date, venue, URL, and price are on by default; description, organizer, and image are off.
7. _(Optional)_ Pick an **MCP connector** to deliver scraped events into Notion, Slack, Google Sheets, etc.
8. Click **Run** — events stream into the dataset as each page is scraped.
9. Download as CSV, Excel, or JSON — or let the connector push them into your tools automatically.

> 🌐 **Proxy**: requests run through **Apify Proxy** (residential group recommended) to reduce the chance of rate-limiting or blocks.
> 💡 First time with a connector? Run once with a connector selected — the run log prints the connector's available tool names, so you know what to put in **Connector tool name**.

---

### 🧩 Input Configuration

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `location` | String | ✔️ Yes | Country--city slug (e.g. `india--ahmedabad`, `united-states--new-york`). See Location Format below. |
| `category` | Enum | ✔️ Yes | One of 18 event categories (Music, Business, Food & Drink, Arts, Sports & Fitness, etc.). Default: `All Events`. |
| `maxEvents` | Integer | ✔️ Yes | Maximum number of events to scrape (1–1000). Default: `100`. |
| `sortBy` | Enum | Optional | Sort order: default (relevance), date, or best match. |
| `startDate` | String | Optional | Only include events starting on or after this date. Format: `YYYY-MM-DD`. |
| `endDate` | String | Optional | Only include events starting on or before this date. Format: `YYYY-MM-DD`. |
| `freeOnly` | Boolean | Optional | Only include free events. Default: `false`. |
| `onlineOnly` | Boolean | Optional | Only include online/virtual events. Default: `false`. |
| **Output fields** | Boolean toggles | Optional | `fieldName`, `fieldDate`, `fieldVenue`, `fieldUrl`, `fieldPrice` (on by default); `fieldDesc`, `fieldOrganizer`, `fieldImage` (off by default). |
| `mcpConnector` | Connector | Optional | Deliver scraped events into a connector you've authorized (Notion, Slack, Google Sheets, Airtable, …). |
| `deliveryMode` | Enum | Optional | `summary` (one call with all events), `chunked` (split a long event list across a few calls), `perEvent` (one call per event), or `none`. Default: `summary`. |
| `mcpTool` | String | Optional | Tool to call on the connector (e.g. `create_page`, `send_message`, `append_row`). |
| `mcpArguments` | Object | Optional | Arguments for the tool; string values support `{placeholders}`. |
| `mcpMessageTemplate` | String | Optional | Template rendered and exposed as the `{message}` placeholder in the tool arguments. |

#### Location Format

Use the Eventbrite URL slug format: `{country}--{city}`

| Location | Slug |
| --- | --- |
| Ahmedabad, India | `india--ahmedabad` |
| Mumbai, India | `india--mumbai` |
| New York, USA | `united-states--new-york` |
| London, UK | `united-kingdom--london` |
| Dubai, UAE | `united-arab-emirates--dubai` |
| Toronto, Canada | `canada--toronto` |
| Sydney, Australia | `australia--sydney` |
| Berlin, Germany | `germany--berlin` |
| Singapore | `singapore--singapore` |

#### Example — Scrape a city's whole event calendar

```json
{
    "location": "india--ahmedabad",
    "category": "All Events",
    "maxEvents": 200
}
````

#### Example — Free music events this month, with description and organizer

```json
{
    "location": "united-states--new-york",
    "category": "Music",
    "maxEvents": 100,
    "startDate": "2026-08-01",
    "endDate": "2026-08-31",
    "freeOnly": true,
    "fieldDesc": true,
    "fieldOrganizer": true
}
```

#### Example — Scrape and post a summary to Slack

```json
{
    "location": "india--ahmedabad",
    "category": "Music",
    "maxEvents": 20,
    "mcpConnector": "<your-slack-connector>",
    "deliveryMode": "summary",
    "mcpTool": "send_message",
    "mcpArguments": { "channel": "#events", "text": "{message}" },
    "mcpMessageTemplate": "Found {eventCount} events in {location} ({category}):\n\n{eventsText}"
}
```

#### Example — Scrape and append one row per event to Google Sheets/Airtable

```json
{
    "location": "united-states--new-york",
    "category": "Business",
    "maxEvents": 50,
    "mcpConnector": "<your-sheets-connector>",
    "deliveryMode": "perEvent",
    "mcpTool": "append_row",
    "mcpArguments": {
        "row": { "Name": "{name}", "Start": "{start}", "Venue": "{venueName}", "URL": "{url}" }
    }
}
```

#### Placeholders available in arguments / template

- **`summary` mode:** `{location}` · `{category}` · `{eventCount}` · `{eventsText}` (formatted list of all events) · `{message}`
- **`chunked` mode:** same as summary, but `{eventsText}` holds one part, plus `{part}` and `{partCount}` (1-based part number and total)
- **`perEvent` mode:** `{name}` · `{url}` · `{start}` · `{end}` · `{timezone}` · `{is_free}` · `{price}` · `{currency}` · `{description}` · `{image_url}` · `{venueName}` · `{venueAddress}` · `{venueCity}` · `{venueCountry}` · `{organizerName}` · `{organizerUrl}` · `{eventText}` (one formatted event block) · `{message}`

***

### 📦 Output Fields

Each field below is included only if its toggle is on (see Input Configuration).

| Field | Description |
| --- | --- |
| `name` | Event name |
| `start` / `end` / `timezone` | Event start/end date-time and timezone |
| `venue` | Object: `name`, `address`, `city`, `country`, `lat`, `lng` |
| `url` | Link to the event page on Eventbrite |
| `is_free` / `price` / `currency` | Whether the event is free, and ticket price/currency if not |
| `description` | Event description/summary |
| `organizer` | Object: `name`, `url` |
| `image_url` | Event cover image URL |

#### Example Output

```json
{
    "name": "Tech Summit Ahmedabad 2026",
    "start": "2026-06-15T10:00:00",
    "end": "2026-06-15T18:00:00",
    "timezone": "Asia/Kolkata",
    "is_free": false,
    "price": "999",
    "currency": "INR",
    "url": "https://www.eventbrite.com/e/tech-summit-ahmedabad-2026-tickets-123456789",
    "venue": {
        "name": "Science City Auditorium",
        "address": "Science City Rd, Sola",
        "city": "Ahmedabad",
        "country": "IN",
        "lat": "23.0395",
        "lng": "72.5096"
    },
    "organizer": {
        "name": "TechEvents Gujarat",
        "url": "https://www.eventbrite.com/o/techevents-gujarat-123456"
    },
    "image_url": "https://img.evbuc.com/..."
}
```

> You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

***

### 🔌 Integrations & Delivery

Deliver scraped events into any MCP connector you've authorized in Apify — no glue code, no webhooks:

- **Notion** — create a page (or split a long event list across several pages)
- **Slack / Discord** — post a summary or per-event alerts to a channel
- **Google Sheets / Airtable** — append a structured row per event
- **Jira / GitHub / Linear** — open a task per event (e.g. for outreach or follow-up)
- …or any other MCP-compatible connector

Credentials stay private — delivery runs through the **Apify MCP Proxy**, so the Actor never sees your connector tokens. You can also consume the dataset directly via the **Apify API**, or wire it into **n8n, Zapier, and Make**.

> ⚙️ **Delivery modes:** `summary` sends all scraped events in one call; `chunked` splits a long event list across a few calls/pages so services like Notion never hit block-count or timeout limits; `perEvent` sends one call per event (great for a row-per-event sheet or a message-per-event feed); `none` saves to the dataset only. MCP delivery only runs on the Apify platform and never affects what's saved to the dataset.

***

### 🛠️ How It Works

`my_actor/main.py` reads the input, then for the given city and category:

1. Fetches the Eventbrite browse page for the location/category and extracts a session token (from cookies, embedded page data, or a bearer-style token) — no login required.
2. Calls Eventbrite's internal search API with that token, paginating page by page (with retry and backoff on rate limits).
3. Parses each raw event into a clean record (name, dates, venue, price, organizer, image), applying date/free/online filters as it goes.
4. Keeps only the output fields you've toggled on, pushes each record to the dataset, and stops once `maxEvents` is reached or events run out.
5. Once scraping finishes, if a connector is configured, delivers the collected events via MCP — summarized, chunked, or one call per event.

**Built with:** [Apify SDK for Python](https://docs.apify.com/sdk/python/) · [httpx](https://www.python-httpx.org/) · [BeautifulSoup4](https://www.crummy.com/software/BeautifulSoup/) · [MCP](https://modelcontextprotocol.io/)

***

### 🆘 Support

For issues, custom scraping requests, or feature suggestions:

**Email**: bhavin.shah@techforceglobal.com

***

#### Need a Custom Pipeline?

Want multi-city batch runs, scheduled refreshes, deeper enrichment, or a full CRM/data-warehouse integration?

#### [📅 Book a Free 15-min Consultation](https://calendly.com/techforce-infotech-pvt-ltd/intro-meeting?month=2026-01)

***

Made with ❤️ by **[Techforce](https://www.techforceglobal.com)**
Specialists in High-Performance Web Scrapers and AI Automation.

***

### Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Eventbrite. Eventbrite® is a trademark of Eventbrite, Inc.; all trademarks are property of their respective owners. The Actor collects only publicly available event listing data and does not log into, or scrape behind the authentication of, any platform. Use the data responsibly and in compliance with applicable laws and the terms of the platforms you operate on.

# Actor input Schema

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

Country and city in Eventbrite URL format: country--city (e.g. india--ahmedabad, united-states--new-york, united-kingdom--london)

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

Event category to filter by.

## `maxEvents` (type: `integer`):

Maximum number of events to scrape.

## `sortBy` (type: `string`):

How to sort the results.

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

Filter events starting on or after this date. Format: YYYY-MM-DD

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

Filter events starting on or before this date. Format: YYYY-MM-DD

## `freeOnly` (type: `boolean`):

If checked, only free events will be scraped.

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

If checked, only online/virtual events will be scraped.

## `fieldName` (type: `boolean`):

Whether to include the event name in the output.

## `fieldDate` (type: `boolean`):

Whether to include the event date and time in the output.

## `fieldVenue` (type: `boolean`):

Whether to include the venue and location details in the output.

## `fieldUrl` (type: `boolean`):

Whether to include the event URL in the output.

## `fieldPrice` (type: `boolean`):

Whether to include the ticket price in the output.

## `fieldDesc` (type: `boolean`):

Whether to include the event description in the output.

## `fieldOrganizer` (type: `boolean`):

Whether to include organizer information in the output.

## `fieldImage` (type: `boolean`):

Whether to include the event image URL in the output.

## `mcpConnector` (type: `string`):

Optionally deliver the scraped events into a connector you have authorized — Notion, Slack, Airtable, Google Sheets, or any MCP-compatible connector. Leave empty to only save results to the dataset.

## `deliveryMode` (type: `string`):

How to deliver to the connector: 'summary' (one call with all scraped events), 'chunked' (split a long event list across a few calls so services like Notion never time out), 'perEvent' (one call per event), or 'none' (save to dataset only).

## `mcpTool` (type: `string`):

Name of the tool to call on the connector (e.g. 'create\_page' for Notion, 'send\_message' for Slack, 'append\_row' for Google Sheets/Airtable). If unsure, run once with a connector selected — the log lists the connector's available tools.

## `mcpArguments` (type: `object`):

Arguments passed to the connector tool. String values support {placeholders}. In 'summary'/'chunked' modes: {location}, {category}, {eventCount}, {eventsText} (formatted event list, or one part of it in chunked mode), {part}/{partCount} (chunked mode only), and {message} (the rendered template below). In 'perEvent' mode: {name}, {url}, {start}, {end}, {timezone}, {is\_free}, {price}, {currency}, {description}, {image\_url}, {venueName}, {venueAddress}, {venueCity}, {venueCountry}, {organizerName}, {organizerUrl}, {eventText} (one formatted event block), and {message}. Example for Slack: {"channel": "#events", "text": "{message}"}.

## `mcpMessageTemplate` (type: `string`):

Optional template rendered and exposed as the {message} placeholder in the tool arguments. Summary example: 'Found {eventCount} events in {location} ({category}):\n\n{eventsText}'. Per-event example: '{name} — {start} at {venueName}\n{url}'.

## Actor input object example

```json
{
  "location": "india--mumbai",
  "category": "All Events",
  "maxEvents": 100,
  "sortBy": "",
  "startDate": "2025-01-01",
  "endDate": "2025-12-31",
  "freeOnly": false,
  "onlineOnly": false,
  "fieldName": true,
  "fieldDate": true,
  "fieldVenue": true,
  "fieldUrl": true,
  "fieldPrice": true,
  "fieldDesc": false,
  "fieldOrganizer": false,
  "fieldImage": false,
  "deliveryMode": "summary",
  "mcpTool": "",
  "mcpArguments": {},
  "mcpMessageTemplate": ""
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("techforce.global/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("techforce.global/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 '{}' |
apify call techforce.global/eventbrite-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eventbrite Scraper - Extract Events by City & Category",
        "description": "Scrape Eventbrite events by city and category, no login or API key required. Extract event name, date, venue, price, organizer, and images as clean JSON, CSV, or Excel. Filter by date range, free-only, or online-only, and auto-deliver results to Notion, Slack, and Airtable.",
        "version": "1.0",
        "x-build-id": "kstlO4RanikLpcMOa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/techforce.global~eventbrite-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-techforce.global-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/techforce.global~eventbrite-scraper/runs": {
            "post": {
                "operationId": "runs-sync-techforce.global-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/techforce.global~eventbrite-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-techforce.global-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",
                "required": [
                    "location",
                    "category",
                    "maxEvents"
                ],
                "properties": {
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Country and city in Eventbrite URL format: country--city (e.g. india--ahmedabad, united-states--new-york, united-kingdom--london)",
                        "default": "india--ahmedabad"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "All Events",
                            "Music",
                            "Business",
                            "Food & Drink",
                            "Arts",
                            "Film & Media",
                            "Sports & Fitness",
                            "Health",
                            "Science & Tech",
                            "Travel & Outdoor",
                            "Charity & Causes",
                            "Religion & Spirituality",
                            "Family & Education",
                            "Fashion",
                            "Home & Lifestyle",
                            "Government",
                            "Community",
                            "Networking"
                        ],
                        "type": "string",
                        "description": "Event category to filter by.",
                        "default": "All Events"
                    },
                    "maxEvents": {
                        "title": "Max events",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of events to scrape.",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "",
                            "date",
                            "best"
                        ],
                        "type": "string",
                        "description": "How to sort the results.",
                        "default": ""
                    },
                    "startDate": {
                        "title": "Start date (from)",
                        "type": "string",
                        "description": "Filter events starting on or after this date. Format: YYYY-MM-DD",
                        "default": ""
                    },
                    "endDate": {
                        "title": "End date (until)",
                        "type": "string",
                        "description": "Filter events starting on or before this date. Format: YYYY-MM-DD",
                        "default": ""
                    },
                    "freeOnly": {
                        "title": "Free events only",
                        "type": "boolean",
                        "description": "If checked, only free events will be scraped.",
                        "default": false
                    },
                    "onlineOnly": {
                        "title": "Online events only",
                        "type": "boolean",
                        "description": "If checked, only online/virtual events will be scraped.",
                        "default": false
                    },
                    "fieldName": {
                        "title": "Include: Event name",
                        "type": "boolean",
                        "description": "Whether to include the event name in the output.",
                        "default": true
                    },
                    "fieldDate": {
                        "title": "Include: Date & time",
                        "type": "boolean",
                        "description": "Whether to include the event date and time in the output.",
                        "default": true
                    },
                    "fieldVenue": {
                        "title": "Include: Venue & location",
                        "type": "boolean",
                        "description": "Whether to include the venue and location details in the output.",
                        "default": true
                    },
                    "fieldUrl": {
                        "title": "Include: Event URL",
                        "type": "boolean",
                        "description": "Whether to include the event URL in the output.",
                        "default": true
                    },
                    "fieldPrice": {
                        "title": "Include: Ticket price",
                        "type": "boolean",
                        "description": "Whether to include the ticket price in the output.",
                        "default": true
                    },
                    "fieldDesc": {
                        "title": "Include: Description",
                        "type": "boolean",
                        "description": "Whether to include the event description in the output.",
                        "default": false
                    },
                    "fieldOrganizer": {
                        "title": "Include: Organizer info",
                        "type": "boolean",
                        "description": "Whether to include organizer information in the output.",
                        "default": false
                    },
                    "fieldImage": {
                        "title": "Include: Event image URL",
                        "type": "boolean",
                        "description": "Whether to include the event image URL in the output.",
                        "default": false
                    },
                    "mcpConnector": {
                        "title": "Deliver to (MCP connector)",
                        "type": "string",
                        "description": "Optionally deliver the scraped events into a connector you have authorized — Notion, Slack, Airtable, Google Sheets, or any MCP-compatible connector. Leave empty to only save results to the dataset."
                    },
                    "deliveryMode": {
                        "title": "Delivery mode",
                        "enum": [
                            "summary",
                            "chunked",
                            "perEvent",
                            "none"
                        ],
                        "type": "string",
                        "description": "How to deliver to the connector: 'summary' (one call with all scraped events), 'chunked' (split a long event list across a few calls so services like Notion never time out), 'perEvent' (one call per event), or 'none' (save to dataset only).",
                        "default": "summary"
                    },
                    "mcpTool": {
                        "title": "Connector tool name",
                        "type": "string",
                        "description": "Name of the tool to call on the connector (e.g. 'create_page' for Notion, 'send_message' for Slack, 'append_row' for Google Sheets/Airtable). If unsure, run once with a connector selected — the log lists the connector's available tools.",
                        "default": ""
                    },
                    "mcpArguments": {
                        "title": "Connector tool arguments",
                        "type": "object",
                        "description": "Arguments passed to the connector tool. String values support {placeholders}. In 'summary'/'chunked' modes: {location}, {category}, {eventCount}, {eventsText} (formatted event list, or one part of it in chunked mode), {part}/{partCount} (chunked mode only), and {message} (the rendered template below). In 'perEvent' mode: {name}, {url}, {start}, {end}, {timezone}, {is_free}, {price}, {currency}, {description}, {image_url}, {venueName}, {venueAddress}, {venueCity}, {venueCountry}, {organizerName}, {organizerUrl}, {eventText} (one formatted event block), and {message}. Example for Slack: {\"channel\": \"#events\", \"text\": \"{message}\"}.",
                        "default": {}
                    },
                    "mcpMessageTemplate": {
                        "title": "Message template",
                        "type": "string",
                        "description": "Optional template rendered and exposed as the {message} placeholder in the tool arguments. Summary example: 'Found {eventCount} events in {location} ({category}):\\n\\n{eventsText}'. Per-event example: '{name} — {start} at {venueName}\\n{url}'.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
