# lu.ma Events Scraper (`schnellscrapers/luma-events-scraper`) Actor

Scrape lu.ma events by URL, calendar, host, city, category, search, or geo. One unified schema covering location, hosts, ticketing, and capacity — pulled directly from lu.ma's public JSON API.

- **URL**: https://apify.com/schnellscrapers/luma-events-scraper.md
- **Developed by:** [Nate Schnell](https://apify.com/schnellscrapers) (community)
- **Categories:** Lead generation, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / 1,000 lu.ma events

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

### What does lu.ma Events Scraper do?

**lu.ma Events Scraper** pulls live event data from [lu.ma](https://lu.ma) — the platform tech, AI, crypto, and startup communities use to host meetups, conferences, hackathons, and dinners. Paste any lu.ma URL (event page, calendar/community, host profile, or featured city), a category slug (`tech`, `ai`, `crypto`, `food`, `arts`, `climate`, `fitness`, `wellness`), a free-text query, or lat/lng coordinates, and get back a clean dataset of every matching event. Great for event marketers tracking sponsorship opportunities, SDRs sourcing leads from public RSVP feeds, conference organizers monitoring competitor calendars, and analysts mapping the live event scene by city or topic.

### What data can you extract from lu.ma?

Each emitted record has 45+ fields covering the full event surface lu.ma publishes:

- **Identity** — `id` (lu.ma's stable api_id, e.g. `evt-pWhbpO3C5CFr3VE`), `url`, `slug`, `name`, `platform` (always `lu.ma`).
- **Timing** — `startAt`, `endAt` (ISO 8601 UTC), `timezone` (IANA).
- **Location** — `locationType` (offline / online / hybrid), `isOnline`, `isInPerson`, `city`, `region`, `country`, `countryCode`, `latitude`, `longitude`, `fullAddress`, `shortAddress`, `addressMode`, `addressVisibility`.
- **Hosts & guests** — `hosts[]` with full social handles (Twitter, LinkedIn, Instagram, TikTok, YouTube, website) for each organizer, plus `featuredGuests[]` for speakers/headliners.
- **Calendar / community** — `calendar` block: name, slug, description, social handles, avatar, the calendar's city.
- **Capacity & RSVPs** — `guestCount`, `ticketCount`, `spotsRemaining`, `isSoldOut`, `isNearCapacity`, `registrationAvailability`, `waitlistEnabled`.
- **Pricing** — `isFree`, `requireApproval`, `price`, `maxPrice`. Per-tier breakdown in `ticketTypes[]` (name, cents, currency, capacity, registered count) when `includeFullDescription` is enabled.
- **Description** — full plain-text `description` (from lu.ma's ProseMirror source) when `includeFullDescription` is enabled or when scraping by event URL.
- **Provenance** — `discoveryContext` (which input mode + value surfaced this record), `source` (the api2.luma.com URL we fetched), `scrapedAt`.

Records are deduplicated by event id across inputs — if you scrape `category=ai` and `city=sf` in the same run, an event that appears in both is emitted once.

### How to use lu.ma Events Scraper

1. Create a free Apify account.
2. Open **lu.ma Events Scraper** and click **Try for free**.
3. Choose one or more input modes:
   - **lu.ma URLs (any kind)** — paste any `lu.ma/...` link. The scraper auto-routes based on what the URL points to (event page, calendar, featured city, category, or host profile).
   - **Event URLs**, **Calendar URLs**, **Host profiles**, **Featured city URLs**, **Discover categories**, **Free-text search queries**, **Geo coordinates** — use the typed inputs if you want strict routing.
4. (Optional) Add filters: `Free events only`, `Online only`, `Minimum guest count`, `Date range start/end`, etc. Filters apply before billing.
5. (Optional) Turn on **Include full description + ticket types** for the richest per-event record.
6. Click **Save & Start**. List endpoints return 25 events per request; runs finish in seconds for typical inputs.
7. Download results from the **Storage** tab in JSON, CSV, Excel, XML, or HTML.

### How much does it cost?

lu.ma Events Scraper is **pay-per-result**: one event per emitted record, no matter how many inputs you query.

- **$0.0001 per event ($0.10 per 1,000 events)** — flat rate across all plans, the cheapest Lu.ma scraper on Apify Store.
- The Apify Free plan includes $5/month of credit, enough for ~50,000 free events.
- **No minimum** — pull 1 event or 50,000.
- Filters and the global `maxItems` cap apply at the source, so filtered-out events aren't billed.

Cost tip: leaving `includeFullDescription` off keeps records compact (no description body, no per-tier ticket breakdown) and avoids a second request per event.

### Input

Every field is optional — you just need to provide at least one source. Common patterns:

```json
// All upcoming AI events on lu.ma's Discover page
{ "categorySlugs": ["ai"], "maxItems": 200 }
````

```json
// Everything on the Founders, Inc. community calendar
{ "calendarUrls": ["https://lu.ma/fdotinc"], "period": "future" }
```

```json
// All upcoming events in San Francisco + NYC, in-person only
{ "cityUrls": ["sf", "nyc"], "inPersonOnly": true, "maxItems": 500 }
```

```json
// One specific event, fully enriched (description, ticket tiers, categories)
{ "eventUrls": ["https://lu.ma/festival"], "includeFullDescription": true }
```

```json
// Multi-source pull with filters
{
  "categorySlugs": ["crypto", "ai"],
  "cityUrls": ["sf", "nyc", "london"],
  "searchQueries": ["hackathon"],
  "freeOnly": true,
  "minGuestCount": 50,
  "dateFrom": "2026-06-01",
  "dateTo": "2026-09-30",
  "maxItems": 1000
}
```

See the **Input** tab for every field with help text.

### Output

One record per lu.ma event. Sample (list mode, AI category):

```json
{
  "platform": "lu.ma",
  "id": "evt-CZfyCM5bTl4Md2H",
  "url": "https://lu.ma/qxdpvsfc",
  "slug": "qxdpvsfc",
  "name": "Maryland Fintech Event",
  "startAt": "2026-05-23T18:00:00.000Z",
  "endAt": "2026-05-23T20:00:00.000Z",
  "timezone": "America/New_York",
  "locationType": "offline",
  "isOnline": false,
  "isInPerson": true,
  "city": "Columbia",
  "region": "Maryland",
  "country": "United States",
  "countryCode": "US",
  "fullAddress": "5885 Robert Oliver Pl, Columbia, MD 21045, USA",
  "latitude": 39.2092878,
  "longitude": -76.8455688,
  "coverUrl": "https://images.lumacdn.com/uploads/vg/f2a173e0-39f7-445c-bce9-c55fb293f2c0.png",
  "visibility": "public",
  "registrationAvailability": "open",
  "guestCount": 8,
  "ticketCount": 8,
  "spotsRemaining": 92,
  "isSoldOut": false,
  "isFree": true,
  "requireApproval": false,
  "waitlistEnabled": true,
  "hosts": [
    {
      "apiId": "usr-6tccATC7C3G6uOf",
      "name": "Soji Okunade",
      "twitterHandle": null,
      "linkedinHandle": null,
      "website": null
    }
  ],
  "featuredGuests": [/* ...8 entries... */],
  "calendar": {
    "apiId": "cal-ANM9zGEAQBT2IxR",
    "name": "Personal",
    "isPersonal": true
  },
  "ticketTypes": [],
  "categories": [],
  "discoveryContext": { "mode": "category", "input": "ai" },
  "source": "https://api2.luma.com/discover/get-paginated-events?slug=ai&pagination_limit=25",
  "scrapedAt": "2026-05-22T15:35:09.868Z"
}
```

With `includeFullDescription: true`, the same record gains `description` (full plain text), `ticketTypes[]` (each tier with `cents` / `currency` / `numTicketsRegistered` / `maxCapacity`), and `categories[]` (lu.ma's tag taxonomy).

Calendars / hosts / cities with no events return zero records (no error). Slugs that 404 log a warning and skip — your run isn't billed for them.

### Integrations

lu.ma Events Scraper works with the full Apify integration set: **Make**, **Zapier**, **n8n**, **Slack**, **Google Drive**, **GitHub**, **Airbyte**, scheduled runs, and the Apify REST API. Trigger runs from your CRM, push fresh events into a Sheet or a database, or fan out webhook notifications when new events are added to a calendar. See [Apify integrations](https://docs.apify.com/platform/integrations).

### FAQ

#### How does lu.ma Events Scraper work?

It hits `api2.luma.com` — the same JSON endpoints lu.ma's own Next.js app uses to render the public Discover, category, calendar, and event pages. No login, no proxy, no headless browser, no rate-limit workarounds. Pagination is cursor-based (`next_cursor`), so the scraper walks through long calendars and category feeds without missing events.

#### What input modes are supported?

Seven: event URL, calendar/community URL, host profile URL, featured city slug, discover category, free-text search query, and geo coordinates (lat/lng). The **lu.ma URLs (any kind)** field auto-routes — paste any lu.ma link and the scraper figures out which mode applies.

#### Can I use lu.ma Events Scraper as an API?

Yes. Trigger a run via the Apify REST API:

```
POST https://api.apify.com/v2/acts/schnellscrapers~luma-events-scraper/runs?token=<APIFY_TOKEN>
```

Use the `run-sync-get-dataset-items` endpoint to get records inline when the run finishes.

#### Can I use it in Python or Node.js?

```python
from apify_client import ApifyClient
client = ApifyClient(token="<APIFY_TOKEN>")
run = client.actor("schnellscrapers/luma-events-scraper").call(run_input={
    "categorySlugs": ["ai", "crypto"],
    "cityUrls": ["sf", "nyc"],
    "freeOnly": True,
    "maxItems": 500,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["city"], item["startAt"])
```

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '<APIFY_TOKEN>' });
const run = await client.actor('schnellscrapers/luma-events-scraper').call({
  categorySlugs: ['ai'],
  includeFullDescription: true,
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### Is it legal to scrape lu.ma?

lu.ma event pages are public and the JSON endpoints we use are the same ones lu.ma's own site consumes. lu.ma's robots.txt only restricts Googlebot from a small set of dashboard paths (`/social-share`, `/in/`, `/company/`, `/session-*`) and contains no rules for other user-agents. The data we collect is what's already publicly visible on the page; storing or republishing it must comply with lu.ma's terms and any applicable privacy laws (GDPR, CCPA).

#### How fresh is the data?

Live — every run hits lu.ma's API directly. Records reflect the exact RSVP and capacity counts at the moment of the request.

#### What's the difference between list mode and detail mode?

List mode (categories, cities, calendars, hosts, search, geo) emits records straight from lu.ma's discover/list endpoints — already includes host info, calendar info, location, coordinates, capacity, and ticket summary. Detail mode (event URLs or `includeFullDescription: true`) adds a per-event fetch that pulls the full text description, ticket-tier breakdown, and category tags. Detail mode roughly doubles the request count.

#### Why is my full address showing only city-level info?

lu.ma lets hosts hide the precise venue until you RSVP. When that's the case, `addressMode` will be `obfuscated` and `fullAddress` will be city-level — `city`, `region`, `country`, `latitude`, and `longitude` still come through.

#### Can I get the attendee / guest list?

Not in this actor. Public guest lists are a separate concern (different buyer, different ToS posture) and may ship as a follow-on actor if there's demand. For now, capacity metrics (`guestCount`, `spotsRemaining`, `isSoldOut`) are the closest signal.

### Your feedback

Found a bug, missing a field, or want a new filter? Open an issue on the actor's Issues tab or email me. Every report gets read.

# Actor input Schema

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

Paste any lu.ma URL — event page (`lu.ma/festival`), calendar/community page (`lu.ma/fdotinc`), city page (`lu.ma/sf`), or host profile (`lu.ma/user/usr-...`). The scraper auto-routes by URL pattern. Use the typed inputs below if you want stricter routing.

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

Specific event URLs or slugs to scrape (one record per event). Examples: `https://lu.ma/festival`, `festival`, `evt-pWhbpO3C5CFr3VE`.

## `calendarUrls` (type: `array`):

Lu.ma calendar (community) pages — each emits one record per event on that calendar. Examples: `https://lu.ma/fdotinc`, `fdotinc`, `cal-iHkz5obZdong4ta`.

## `hostUrls` (type: `array`):

Lu.ma user profiles — each emits one record per event the host is running. Examples: `https://lu.ma/user/usr-6tccATC7C3G6uOf`, `usr-6tccATC7C3G6uOf`, `https://lu.ma/u/<username>`.

## `cityUrls` (type: `array`):

Lu.ma featured-city pages. Examples: `https://lu.ma/sf`, `sf`, `nyc`, `london`. Resolves to lu.ma's curated feed for that city.

## `categorySlugs` (type: `array`):

Lu.ma category slugs from the Discover page. Common values: `tech`, `ai`, `crypto`, `food`, `arts`, `climate`, `fitness`, `wellness`.

## `searchQueries` (type: `array`):

Keywords sent to lu.ma's discover search (e.g. `hackathon`, `solana builders`, `pickleball`).

## `geoCoordinates` (type: `array`):

Latitude/longitude pairs — emits the nearest events lu.ma's discover surface returns for each point. Each item is an object: `{"latitude": 37.7749, "longitude": -122.4194}`.

## `period` (type: `string`):

For calendar and host modes: scrape upcoming events (`future`) or past events (`past`). Discover/category/city/query/geo always return upcoming events.

## `includeFullDescription` (type: `boolean`):

Off by default to keep runs cheap. When on, the scraper fetches each event's detail page (`/url?url=<slug>`) and populates `description`, `ticketTypes`, and `categories` for records discovered via list endpoints. Roughly doubles the per-event request count.

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

Hard cap on emitted dataset records across all inputs. Leave empty for no cap.

## `maxItemsPerSource` (type: `integer`):

Hard cap per input source (e.g. per category, per calendar, per city). Useful when you want a quick sample across many sources.

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

Drop events that have a paid ticket type.

## `paidOnly` (type: `boolean`):

Drop free events.

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

Keep events whose `locationType` is `online` or `hybrid`.

## `inPersonOnly` (type: `boolean`):

Keep events whose `locationType` is `offline` or `hybrid`.

## `minGuestCount` (type: `integer`):

Drop events with fewer than this many RSVPs / registered guests. Use 0 to disable.

## `dateFrom` (type: `string`):

Drop events that start before this ISO date/time. Example: `2026-06-01` or `2026-06-01T00:00:00Z`.

## `dateTo` (type: `string`):

Drop events that start after this ISO date/time.

## `paginationLimit` (type: `integer`):

Page size for list endpoints. Higher = fewer requests but larger responses. Defaults to 25.

## `proxyMode` (type: `string`):

lu.ma's public API doesn't block Apify cloud IPs in normal use, so `none` is the default. Switch to a proxy if you see HTTP 429/403 on long runs.

## `dryRun` (type: `boolean`):

Skip pushing records to the dataset. Useful for cost-estimation runs.

## Actor input object example

```json
{
  "startUrls": [],
  "eventUrls": [],
  "calendarUrls": [],
  "hostUrls": [],
  "cityUrls": [],
  "categorySlugs": [],
  "searchQueries": [],
  "geoCoordinates": [],
  "period": "future",
  "includeFullDescription": false,
  "freeOnly": false,
  "paidOnly": false,
  "onlineOnly": false,
  "inPersonOnly": false,
  "minGuestCount": 0,
  "paginationLimit": 25,
  "proxyMode": "none",
  "dryRun": false
}
```

# Actor output Schema

## `events` (type: `string`):

Default dataset of event records. Key fields: name, startAt, city, country, locationType, guestCount, isFree, hosts, calendar, url.

# 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": [],
    "eventUrls": [],
    "calendarUrls": [],
    "hostUrls": [],
    "cityUrls": [],
    "categorySlugs": [],
    "searchQueries": [],
    "geoCoordinates": []
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "startUrls": [],
    "eventUrls": [],
    "calendarUrls": [],
    "hostUrls": [],
    "cityUrls": [],
    "categorySlugs": [],
    "searchQueries": [],
    "geoCoordinates": [],
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [],
  "eventUrls": [],
  "calendarUrls": [],
  "hostUrls": [],
  "cityUrls": [],
  "categorySlugs": [],
  "searchQueries": [],
  "geoCoordinates": []
}' |
apify call schnellscrapers/luma-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "lu.ma Events Scraper",
        "description": "Scrape lu.ma events by URL, calendar, host, city, category, search, or geo. One unified schema covering location, hosts, ticketing, and capacity — pulled directly from lu.ma's public JSON API.",
        "version": "0.1",
        "x-build-id": "curY9jajpjsplduyr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/schnellscrapers~luma-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-schnellscrapers-luma-events-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/schnellscrapers~luma-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-schnellscrapers-luma-events-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/schnellscrapers~luma-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-schnellscrapers-luma-events-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "lu.ma URLs (any kind)",
                        "type": "array",
                        "description": "Paste any lu.ma URL — event page (`lu.ma/festival`), calendar/community page (`lu.ma/fdotinc`), city page (`lu.ma/sf`), or host profile (`lu.ma/user/usr-...`). The scraper auto-routes by URL pattern. Use the typed inputs below if you want stricter routing.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "eventUrls": {
                        "title": "Event URLs",
                        "type": "array",
                        "description": "Specific event URLs or slugs to scrape (one record per event). Examples: `https://lu.ma/festival`, `festival`, `evt-pWhbpO3C5CFr3VE`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "calendarUrls": {
                        "title": "Calendar / community URLs",
                        "type": "array",
                        "description": "Lu.ma calendar (community) pages — each emits one record per event on that calendar. Examples: `https://lu.ma/fdotinc`, `fdotinc`, `cal-iHkz5obZdong4ta`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "hostUrls": {
                        "title": "Host / organizer profiles",
                        "type": "array",
                        "description": "Lu.ma user profiles — each emits one record per event the host is running. Examples: `https://lu.ma/user/usr-6tccATC7C3G6uOf`, `usr-6tccATC7C3G6uOf`, `https://lu.ma/u/<username>`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cityUrls": {
                        "title": "Featured city URLs / slugs",
                        "type": "array",
                        "description": "Lu.ma featured-city pages. Examples: `https://lu.ma/sf`, `sf`, `nyc`, `london`. Resolves to lu.ma's curated feed for that city.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categorySlugs": {
                        "title": "Discover categories",
                        "type": "array",
                        "description": "Lu.ma category slugs from the Discover page. Common values: `tech`, `ai`, `crypto`, `food`, `arts`, `climate`, `fitness`, `wellness`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Free-text search queries",
                        "type": "array",
                        "description": "Keywords sent to lu.ma's discover search (e.g. `hackathon`, `solana builders`, `pickleball`).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "geoCoordinates": {
                        "title": "Geo coordinates (nearby events)",
                        "type": "array",
                        "description": "Latitude/longitude pairs — emits the nearest events lu.ma's discover surface returns for each point. Each item is an object: `{\"latitude\": 37.7749, \"longitude\": -122.4194}`."
                    },
                    "period": {
                        "title": "Time window",
                        "enum": [
                            "future",
                            "past"
                        ],
                        "type": "string",
                        "description": "For calendar and host modes: scrape upcoming events (`future`) or past events (`past`). Discover/category/city/query/geo always return upcoming events.",
                        "default": "future"
                    },
                    "includeFullDescription": {
                        "title": "Include full description + ticket types",
                        "type": "boolean",
                        "description": "Off by default to keep runs cheap. When on, the scraper fetches each event's detail page (`/url?url=<slug>`) and populates `description`, `ticketTypes`, and `categories` for records discovered via list endpoints. Roughly doubles the per-event request count.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum records (total)",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Hard cap on emitted dataset records across all inputs. Leave empty for no cap."
                    },
                    "maxItemsPerSource": {
                        "title": "Maximum records per input",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Hard cap per input source (e.g. per category, per calendar, per city). Useful when you want a quick sample across many sources."
                    },
                    "freeOnly": {
                        "title": "Free events only",
                        "type": "boolean",
                        "description": "Drop events that have a paid ticket type.",
                        "default": false
                    },
                    "paidOnly": {
                        "title": "Paid events only",
                        "type": "boolean",
                        "description": "Drop free events.",
                        "default": false
                    },
                    "onlineOnly": {
                        "title": "Online / virtual events only",
                        "type": "boolean",
                        "description": "Keep events whose `locationType` is `online` or `hybrid`.",
                        "default": false
                    },
                    "inPersonOnly": {
                        "title": "In-person events only",
                        "type": "boolean",
                        "description": "Keep events whose `locationType` is `offline` or `hybrid`.",
                        "default": false
                    },
                    "minGuestCount": {
                        "title": "Minimum guest count",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Drop events with fewer than this many RSVPs / registered guests. Use 0 to disable.",
                        "default": 0
                    },
                    "dateFrom": {
                        "title": "Date range start (ISO)",
                        "type": "string",
                        "description": "Drop events that start before this ISO date/time. Example: `2026-06-01` or `2026-06-01T00:00:00Z`."
                    },
                    "dateTo": {
                        "title": "Date range end (ISO)",
                        "type": "string",
                        "description": "Drop events that start after this ISO date/time."
                    },
                    "paginationLimit": {
                        "title": "Items per API request",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Page size for list endpoints. Higher = fewer requests but larger responses. Defaults to 25.",
                        "default": 25
                    },
                    "proxyMode": {
                        "title": "Proxy mode",
                        "enum": [
                            "none",
                            "apify_proxy_datacenter",
                            "apify_proxy_residential"
                        ],
                        "type": "string",
                        "description": "lu.ma's public API doesn't block Apify cloud IPs in normal use, so `none` is the default. Switch to a proxy if you see HTTP 429/403 on long runs.",
                        "default": "none"
                    },
                    "dryRun": {
                        "title": "Dry run",
                        "type": "boolean",
                        "description": "Skip pushing records to the dataset. Useful for cost-estimation runs.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
