# Meetup + Lu.ma Events Scraper (`crawlerbros/meetup-luma-scraper`) Actor

Scrape events from Meetup.com and Lu.ma, title, date, venue, organizer, attendee count, photo, RSVP status, and discovery feeds (search, by group, by calendar, nearby).

- **URL**: https://apify.com/crawlerbros/meetup-luma-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 16 bookmarks
- **User rating**: 5.00 out of 5 stars

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

## Meetup + Lu.ma Events Scraper

Scrape events from **Meetup.com** and **Lu.ma** in a single actor — search for events near you, browse calendars, fetch events by URL, or discover trending gatherings worldwide. Returns event title, date, venue, organizer, attendee count, photo, RSVP info, and ticket details.

No login required. No cookies. Works out of the box.

### Use cases

- Build event-discovery dashboards across Meetup + Lu.ma in one feed
- Find local tech meetups in a city
- Track new events posted by a community / calendar / organizer
- Aggregate conference and networking events for a region
- Build a "what's happening this weekend" CRM
- Compare Lu.ma vs Meetup ecosystems by topic

### Platforms

Pick `platform=meetup` for community RSVP events, or `platform=luma` for the modern conference / community calendar ecosystem.

### Modes by platform

| Mode | Meetup | Lu.ma |
|---|---|---|
| `searchEvents` | Yes (find search) | Yes (city + keyword) |
| `byEvent` | Yes (event ID) | Yes (event slug) |
| `byGroup` / `byOrganizer` | Yes | — |
| `groupEvents` | Yes (upcoming events for a group) | — |
| `byCalendar` | — | Yes (community calendar) |
| `discoverNearby` | — | Yes (lat/lng or city) |
| `discoverTrending` | — | Yes (featured cities) |
| `byUrl` | Yes (auto-routed) | Yes (auto-routed) |

### Input

| Field | Type | Description |
|---|---|---|
| `platform` | enum | `meetup` or `luma`. |
| `mode` | enum | What to scrape (see modes). |
| `query` | string | Free-text keyword for search. |
| `location` | string | City + state/country (Meetup search, Luma city resolver). |
| `country` | enum | ISO 3166-1 country (Meetup search). |
| `category` | enum | Meetup topic (`tech`, `social-activities`, `music`, ...). |
| `eventType` | enum | `physical`, `online`, or `any`. |
| `sortBy` | enum | `relevance`, `best`, `newest`, `soonest`. |
| `luma_period` | enum | `upcoming`, `past`, `all`. |
| `urls` | list | Full URLs (auto-routed). |
| `slugs` | list | Event/group/calendar slugs. |
| `eventIds` | list | Meetup event IDs (paired with `slugs`). |
| `lat`, `lng` | number | Latitude/longitude (Lu.ma nearby). |
| `lumaCity` | enum | Lu.ma featured city (San Francisco, Tokyo, ...). |
| `freeOnly` | bool | Drop paid events. |
| `minAttendees` | int | Drop events with fewer than this many RSVPs. |
| `maxItems` | int | Hard cap (1-1000). |
| `autoEscalateOnBlock` | bool | Auto-engage Apify Proxy on 403. |

### Examples

#### Search Meetup events (default daily-test)

```json
{
  "platform": "meetup",
  "mode": "searchEvents",
  "query": "tech",
  "location": "san francisco",
  "category": "tech",
  "maxItems": 10
}
````

#### Lu.ma events in San Francisco

```json
{
  "platform": "luma",
  "mode": "discoverNearby",
  "lumaCity": "sf",
  "luma_period": "upcoming",
  "maxItems": 50
}
```

#### Lu.ma calendar (community page)

```json
{
  "platform": "luma",
  "mode": "byCalendar",
  "slugs": ["sf"],
  "maxItems": 30
}
```

#### Meetup group's upcoming events

```json
{
  "platform": "meetup",
  "mode": "groupEvents",
  "slugs": ["meetup-group-englishkoreanexchange"],
  "maxItems": 20
}
```

#### Auto-routed URLs (mixed Meetup + Lu.ma)

```json
{
  "platform": "meetup",
  "mode": "byUrl",
  "urls": [
    "https://www.meetup.com/meetup-group-englishkoreanexchange/events/314367217/",
    "https://lu.ma/h85fumdt"
  ]
}
```

### Output

Each record is an event with these fields (`null`/empty values are omitted):

```json
{
  "platform": "meetup",
  "id": "314367217",
  "name": "Asian Appreciation BBQ Party at the Park",
  "url": "https://www.meetup.com/meetup-group-englishkoreanexchange/events/314367217/",
  "startAt": "2026-05-16T12:00:00-07:00",
  "eventType": "PHYSICAL",
  "rsvpState": "JOIN_APPROVAL",
  "guestCount": 100,
  "isFree": true,
  "imageUrl": "https://secure.meetupstatic.com/photos/event/...",
  "group": {
    "id": "36704443",
    "name": "Los Angeles Korean-English Language Exchange Group",
    "urlname": "meetup-group-englishkoreanexchange",
    "url": "https://www.meetup.com/meetup-group-englishkoreanexchange",
    "rating": 4.92,
    "ratingCount": 1350
  },
  "groupName": "Los Angeles Korean-English Language Exchange Group",
  "groupUrlname": "meetup-group-englishkoreanexchange",
  "venueName": "...",
  "city": "Los Angeles",
  "country": "US",
  "scrapedAt": "2026-05-09T20:51:08.123456+00:00"
}
```

Lu.ma records use the same flat schema with `platform: "luma"` and Lu.ma-specific fields like `calendar.id`, `ticketCount`, `requireApproval`, `featured_city`, etc.

### FAQs

**Q: Do I need a Meetup or Lu.ma account?**
A: No. The actor scrapes public pages only.

**Q: How does Lu.ma search work? They don't have a search bar.**
A: We use Lu.ma's `/discover` endpoint to enumerate featured cities, fetch each city's upcoming events via the public `api.lu.ma/discover/get-paginated-events` API, then filter client-side by your `query`.

**Q: Can I get events farther in the future / past?**
A: Set `luma_period=past` for past events. Meetup only exposes upcoming events on its public find page.

**Q: Why is `description` sometimes missing?**
A: Meetup's search-page Apollo cache only includes the first 100-200 chars of each description. To get the full description, fetch the event detail (mode=byEvent) — that page includes the full body.

**Q: How do you parse a Lu.ma URL?**
A: `lu.ma/<slug>` could be either an event or a calendar; the actor probes the page's `__NEXT_DATA__.initialData.kind` to disambiguate, then routes to the right record builder.

**Q: Are Meetup events worldwide?**
A: Yes — Meetup search supports any country (US, UK, DE, FR, IN, BR, JP, ...). Set `country` to narrow.

**Q: Are Lu.ma cities pre-defined?**
A: Lu.ma's discover page lists ~40 featured cities globally. The `lumaCity` enum mirrors that list. To find a non-featured location, use `lat` + `lng` and the actor picks the closest featured city.

**Q: What about RSVPs / attendees?**
A: We expose `guestCount` (Meetup `rsvps.totalCount`, Lu.ma `guest_count`). The full attendee list is only visible to logged-in users on both platforms.

### Limitations

- **Meetup attendee names** are private to each event's host; only counts are returned.
- **Lu.ma free-text search** is implemented client-side over discover-fetched events (no server-side keyword search exists publicly).
- **Past events** on Meetup are not indexed by the public find page; use `byUrl` with the specific event link if you have it.
- **RSVP / register actions** are read-only; the actor does not RSVP or register.

# Actor input Schema

## `platform` (type: `string`):

Which platform to scrape.

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

What to scrape. Some modes are platform-specific — see the Mode-by-platform reference in the README.

## `query` (type: `string`):

Free-text keyword. Required for `mode=searchEvents`.

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

City + state/country. Examples: `san francisco`, `New York, NY`, `London, UK`. Used by Meetup search (`location=`) and the Luma nearby city resolver.

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

Meetup category slug. Filters search results to a topic area.

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

ISO 3166-1 alpha-2 country code (lowercase). E.g. `us`, `gb`, `de`, `fr`. Used by Meetup search.

## `eventType` (type: `string`):

In-person, online, or both. Defaults to both.

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

Sort order for Meetup search results.

## `luma_period` (type: `string`):

Time window for Lu.ma calendar / discover queries.

## `urls` (type: `array`):

Full URLs to scrape. Auto-routes by host: `meetup.com/<group>` → group; `meetup.com/<group>/events/<id>` → event; `lu.ma/<slug>` → event or calendar.

## `slugs` (type: `array`):

Lu.ma event/calendar slugs (e.g. `sf`, `h85fumdt`) or Meetup group urlnames (e.g. `meetup-group-englishkoreanexchange`).

## `eventIds` (type: `array`):

Meetup numeric event IDs (e.g. `314367217`). Used together with `slugs` (group urlnames) — pair index-aligned.

## `lat` (type: `number`):

Latitude in decimal degrees. Used by `mode=discoverNearby` on Lu.ma to find the closest featured city.

## `lng` (type: `number`):

Longitude in decimal degrees. Used by `mode=discoverNearby` on Lu.ma to find the closest featured city.

## `lumaCity` (type: `string`):

Curated Lu.ma featured city slug (the slug from `lu.ma/<slug>`). Use this OR `lat`/`lng` for nearby discovery.

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

Drop events that charge for entry / tickets.

## `minAttendees` (type: `integer`):

Drop events with fewer than this many RSVPs / guests.

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

Hard cap on emitted records.

## `autoEscalateOnBlock` (type: `boolean`):

If true (default), the actor automatically engages Apify Proxy when it hits HTTP 403 from a raw datacenter IP.

## `proxyGroups` (type: `array`):

Apify proxy groups to use when auto-escalating. Empty = datacenter (default), then RESIDENTIAL fallback.

## Actor input object example

```json
{
  "platform": "meetup",
  "mode": "searchEvents",
  "query": "tech",
  "location": "san francisco",
  "category": "tech",
  "urls": [],
  "slugs": [],
  "eventIds": [],
  "freeOnly": false,
  "maxItems": 10,
  "autoEscalateOnBlock": true,
  "proxyGroups": []
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset of all scraped events.

# 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 = {
    "platform": "meetup",
    "mode": "searchEvents",
    "query": "tech",
    "location": "san francisco",
    "category": "tech",
    "freeOnly": false,
    "maxItems": 10,
    "autoEscalateOnBlock": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/meetup-luma-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 = {
    "platform": "meetup",
    "mode": "searchEvents",
    "query": "tech",
    "location": "san francisco",
    "category": "tech",
    "freeOnly": False,
    "maxItems": 10,
    "autoEscalateOnBlock": True,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/meetup-luma-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 '{
  "platform": "meetup",
  "mode": "searchEvents",
  "query": "tech",
  "location": "san francisco",
  "category": "tech",
  "freeOnly": false,
  "maxItems": 10,
  "autoEscalateOnBlock": true
}' |
apify call crawlerbros/meetup-luma-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Meetup + Lu.ma Events Scraper",
        "description": "Scrape events from Meetup.com and Lu.ma, title, date, venue, organizer, attendee count, photo, RSVP status, and discovery feeds (search, by group, by calendar, nearby).",
        "version": "1.0",
        "x-build-id": "1yIL5AV5odCvxOyaf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~meetup-luma-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-meetup-luma-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/crawlerbros~meetup-luma-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-meetup-luma-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/crawlerbros~meetup-luma-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-meetup-luma-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": [
                    "platform",
                    "mode"
                ],
                "properties": {
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "meetup",
                            "luma"
                        ],
                        "type": "string",
                        "description": "Which platform to scrape.",
                        "default": "meetup"
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "searchEvents",
                            "byEvent",
                            "byGroup",
                            "groupEvents",
                            "byOrganizer",
                            "byCalendar",
                            "discoverNearby",
                            "discoverTrending",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "What to scrape. Some modes are platform-specific — see the Mode-by-platform reference in the README.",
                        "default": "searchEvents"
                    },
                    "query": {
                        "title": "Search query (mode=searchEvents)",
                        "type": "string",
                        "description": "Free-text keyword. Required for `mode=searchEvents`."
                    },
                    "location": {
                        "title": "Location (Meetup search / Luma nearby)",
                        "type": "string",
                        "description": "City + state/country. Examples: `san francisco`, `New York, NY`, `London, UK`. Used by Meetup search (`location=`) and the Luma nearby city resolver."
                    },
                    "category": {
                        "title": "Category (Meetup search)",
                        "enum": [
                            "tech",
                            "career-business",
                            "social-activities",
                            "language",
                            "outdoors-adventure",
                            "health-wellness",
                            "music",
                            "arts-culture",
                            "food-drink",
                            "games",
                            "movements",
                            "religion-spirituality",
                            "writing",
                            "lgbtq",
                            "parents-family",
                            "fashion-beauty",
                            "fitness",
                            "pets-animals",
                            "sports-fitness",
                            "support",
                            "dancing",
                            "education-learning",
                            "movies-film",
                            "cars-motorcycles",
                            "hobbies-crafts",
                            "photography",
                            "book-clubs",
                            "singles",
                            "new-age-spirituality",
                            "paranormal"
                        ],
                        "type": "string",
                        "description": "Meetup category slug. Filters search results to a topic area."
                    },
                    "country": {
                        "title": "Country (Meetup search)",
                        "enum": [
                            "us",
                            "ca",
                            "gb",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "se",
                            "ch",
                            "ie",
                            "au",
                            "nz",
                            "in",
                            "sg",
                            "jp",
                            "br",
                            "mx",
                            "ar",
                            "be",
                            "at",
                            "pl",
                            "pt",
                            "dk",
                            "fi",
                            "no",
                            "cz",
                            "il",
                            "ae",
                            "za"
                        ],
                        "type": "string",
                        "description": "ISO 3166-1 alpha-2 country code (lowercase). E.g. `us`, `gb`, `de`, `fr`. Used by Meetup search."
                    },
                    "eventType": {
                        "title": "Event type (Meetup search)",
                        "enum": [
                            "any",
                            "physical",
                            "online"
                        ],
                        "type": "string",
                        "description": "In-person, online, or both. Defaults to both."
                    },
                    "sortBy": {
                        "title": "Sort order (Meetup search)",
                        "enum": [
                            "relevance",
                            "best",
                            "newest",
                            "soonest"
                        ],
                        "type": "string",
                        "description": "Sort order for Meetup search results."
                    },
                    "luma_period": {
                        "title": "Lu.ma period filter",
                        "enum": [
                            "upcoming",
                            "past",
                            "all"
                        ],
                        "type": "string",
                        "description": "Time window for Lu.ma calendar / discover queries."
                    },
                    "urls": {
                        "title": "Event / Group / Calendar URLs (mode=byUrl / byEvent / byGroup / byCalendar)",
                        "type": "array",
                        "description": "Full URLs to scrape. Auto-routes by host: `meetup.com/<group>` → group; `meetup.com/<group>/events/<id>` → event; `lu.ma/<slug>` → event or calendar.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "slugs": {
                        "title": "Event / Group / Calendar slugs (mode=byEvent / byGroup / byCalendar)",
                        "type": "array",
                        "description": "Lu.ma event/calendar slugs (e.g. `sf`, `h85fumdt`) or Meetup group urlnames (e.g. `meetup-group-englishkoreanexchange`).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "eventIds": {
                        "title": "Meetup event IDs (mode=byEvent on Meetup)",
                        "type": "array",
                        "description": "Meetup numeric event IDs (e.g. `314367217`). Used together with `slugs` (group urlnames) — pair index-aligned.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "lat": {
                        "title": "Latitude (Lu.ma discoverNearby)",
                        "minimum": -90,
                        "maximum": 90,
                        "type": "number",
                        "description": "Latitude in decimal degrees. Used by `mode=discoverNearby` on Lu.ma to find the closest featured city."
                    },
                    "lng": {
                        "title": "Longitude (Lu.ma discoverNearby)",
                        "minimum": -180,
                        "maximum": 180,
                        "type": "number",
                        "description": "Longitude in decimal degrees. Used by `mode=discoverNearby` on Lu.ma to find the closest featured city."
                    },
                    "lumaCity": {
                        "title": "Lu.ma city slug (mode=discoverNearby)",
                        "enum": [
                            "sf",
                            "nyc",
                            "la",
                            "sd",
                            "dc",
                            "boston",
                            "chicago",
                            "seattle",
                            "austin",
                            "miami",
                            "atlanta",
                            "denver",
                            "portland",
                            "philadelphia",
                            "minneapolis",
                            "dallas",
                            "houston",
                            "phoenix",
                            "las-vegas",
                            "honolulu",
                            "salt-lake-city",
                            "london",
                            "berlin",
                            "paris",
                            "amsterdam",
                            "barcelona",
                            "madrid",
                            "lisbon",
                            "dublin",
                            "rome",
                            "milan",
                            "munich",
                            "hamburg",
                            "vienna",
                            "zurich",
                            "geneva",
                            "lausanne",
                            "stockholm",
                            "copenhagen",
                            "helsinki",
                            "warsaw",
                            "budapest",
                            "prague",
                            "brussels",
                            "istanbul",
                            "tokyo",
                            "seoul",
                            "taipei",
                            "hongkong",
                            "singapore",
                            "kuala-lumpur",
                            "bangkok",
                            "jakarta",
                            "manila",
                            "ho-chi-minh-city",
                            "mumbai",
                            "new-delhi",
                            "bengaluru",
                            "tel-aviv",
                            "dubai",
                            "lagos",
                            "nairobi",
                            "capetown",
                            "toronto",
                            "vancouver",
                            "montreal",
                            "calgary",
                            "waterloo_ca",
                            "sydney",
                            "melbourne",
                            "brisbane",
                            "auckland",
                            "rio",
                            "saopaulo",
                            "mexico-city",
                            "medellin",
                            "bogota",
                            "buenos-aires"
                        ],
                        "type": "string",
                        "description": "Curated Lu.ma featured city slug (the slug from `lu.ma/<slug>`). Use this OR `lat`/`lng` for nearby discovery."
                    },
                    "freeOnly": {
                        "title": "Free events only (filter)",
                        "type": "boolean",
                        "description": "Drop events that charge for entry / tickets.",
                        "default": false
                    },
                    "minAttendees": {
                        "title": "Min attendees (filter)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop events with fewer than this many RSVPs / guests."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    },
                    "autoEscalateOnBlock": {
                        "title": "Auto-escalate to Apify proxy on block",
                        "type": "boolean",
                        "description": "If true (default), the actor automatically engages Apify Proxy when it hits HTTP 403 from a raw datacenter IP.",
                        "default": true
                    },
                    "proxyGroups": {
                        "title": "Apify proxy groups (used on auto-escalation)",
                        "type": "array",
                        "description": "Apify proxy groups to use when auto-escalating. Empty = datacenter (default), then RESIDENTIAL fallback.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
