# Luma Event Scraper (`solidcode/luma-scraper`) Actor

\[💰 $2.5 / 1K] Extract public events from Luma (lu.ma) — titles, dates, hosts, venues with coordinates, ticket prices, sold-out status, categories, and host social handles. Works on event pages, city/place pages, category pages, calendar/community pages, and the global discover feed.

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

## Pricing

from $2.50 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Luma Event Scraper

Extract structured event data from **Luma (lu.ma)** — the RSVP platform powering AI meetups, crypto summits, hackathons, founder dinners, and city-scoped community gatherings. Drop in event URLs, calendars, communities, cities, or free-text search queries and get a clean row per event with hosts, location, ticketing, sessions, and featured guests. Built for **event marketers, community builders, sales teams, and trend researchers** who need a reliable feed of upcoming Luma events without manually scrolling discover pages every morning.

### Why This Scraper?

- **8 native Luma categories** — AI, Tech, Crypto, Food & Drink, Arts & Culture, Climate, Fitness, Wellness — matching Luma's own taxonomy exactly, so your filters line up with the discover UI without remapping.
- **6 source types in one input** — direct event pages, community calendars, city pages, category feeds, the global discover feed, and user-profile hosting pages, all mixable in a single run.
- **City-scoped search** — pair free-text queries with a Luma city slug (`san-francisco`, `nyc`, `london`, `tokyo`) so "AI" stays scoped to the metro you actually care about.
- **Featured guests up to 10 per event** — captured as structured rows with name, slug, profile URL, avatar, bio, and social handles (Twitter, Instagram, LinkedIn, YouTube, TikTok, website).
- **Clean plain-text descriptions** — Luma stores event descriptions as ProseMirror JSON; we convert them to readable plain text so your downstream tools don't have to.
- **Multi-session events captured** — recurring conferences and multi-day summits return every individual session with its own start and end timestamps.
- **Public registration questions exposed** — for every event you see the question label, type, and whether it's required, useful for understanding audience qualification at a glance.
- **Smart date-range early-stop** — when you set a `dateTo`, the actor stops paginating the ascending feed as soon as it passes your window, so you never pay for events outside the range you asked for.
- **Pay-Per-Result pricing at $2.50 per 1,000 events** — no compute charges, no surprise overage, and you only pay for rows that survive your category, date, type, and pricing filters.

### Use Cases

**Market Intelligence**
- Track which AI / crypto / climate communities are most active by city and month
- Benchmark conference attendance trends across categories
- Map the competitive landscape for your own meetup series

**Lead Generation**
- Find event organizers in your target industry with their social handles attached
- Identify featured speakers and panelists for outreach
- Build prospect lists from recurring hosts in your city

**Community Research**
- Monitor what topics your audience is gathering around
- Discover emerging communities before they're widely known
- Track seasonal patterns in event programming

**Sponsorship & Partnerships**
- Find paid events near capacity in your category — high-intent sponsorship targets
- Surface free, high-attendance events open to brand activation
- Audit how often specific hosts run events to gauge partnership longevity

**Trend Spotting**
- Detect rising event themes by tracking category-tag frequency over time
- Spot geographic clusters of innovation (AI Tokyo, climate Berlin, crypto Lisbon)
- Watch what topics venture-backed communities like YC, a16z, and South Park Commons are programming

**Calendar & Event Discovery**
- Build a personal "what's worth attending this week" digest
- Populate your CRM or CMS with curated upcoming events
- Power a public-facing event directory for your niche

### Getting Started

Paste any combination of Luma URLs and search queries, then add filters. Below are four input examples ranging from simple to advanced.

**1. Quickest start — pull this week's discover feed**

```json
{
  "lumaUrls": ["https://lu.ma/discover"],
  "maxResults": 100
}
````

**2. Find AI events in San Francisco**

```json
{
  "searchQueries": ["AI"],
  "discoverCity": "san-francisco",
  "category": "ai",
  "maxResults": 250
}
```

**3. Track the Y Combinator community calendar**

```json
{
  "lumaUrls": ["https://lu.ma/yc"],
  "scrapeEventDetails": true,
  "includeFeaturedGuests": true,
  "maxResults": 500
}
```

**4. Wide-net research — paid crypto events worldwide for the next month**

```json
{
  "lumaUrls": [
    "https://lu.ma/crypto",
    "https://lu.ma/nyc",
    "https://lu.ma/london",
    "https://lu.ma/sf"
  ],
  "searchQueries": ["Web3", "DeFi", "blockchain"],
  "category": "crypto",
  "pricing": "paid",
  "dateFrom": "2026-06-01",
  "dateTo": "2026-06-30",
  "scrapeEventDetails": true,
  "maxResults": 2000
}
```

### Input Reference

#### Sources

| Parameter | Type | Default | Description |
|---|---|---|---|
| `lumaUrls` | array of strings | `["https://lu.ma/discover"]` | Luma URLs of any type — event, calendar, community, city, category, discover, or user-profile. Mix freely in one list. |
| `searchQueries` | array of strings | `[]` | Free-text queries run against Luma's discover feed (e.g. "AI Tokyo", "Brooklyn music"). Each runs independently. |
| `discoverCity` | string | none | Optional Luma city slug (`san-francisco`, `nyc`, `london`, `tokyo`). When set, every search query is scoped to this city. |

#### Filters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `category` | enum | All categories | Restrict to one of: AI, Tech, Crypto, Food & Drink, Arts & Culture, Climate, Fitness, Wellness. |
| `dateFrom` | date | none | Only include events starting on or after this date (YYYY-MM-DD). |
| `dateTo` | date | none | Only include events starting on or before this date (YYYY-MM-DD). Triggers smart early-stop on ascending feeds. |
| `eventType` | enum | All | All / In-person only / Virtual only. |
| `pricing` | enum | All | All / Free only / Paid only. |

#### Output Control

| Parameter | Type | Default | Description |
|---|---|---|---|
| `scrapeEventDetails` | boolean | `true` | Fetch the full event payload — description, ticket types, sessions, richer hosts, registration questions. Turn off for faster, lighter runs. |
| `includeFeaturedGuests` | boolean | `false` | Attach Luma's public featured-guest list (up to 10 names per event). Full attendee lists are organizer-only and never available publicly. |

#### Limits

| Parameter | Type | Default | Description |
|---|---|---|---|
| `maxEventsPerUrl` | integer | 1000 | Cap on events per URL or query. Set `0` for no per-source cap. |
| `maxResults` | integer | 1000 | Hard cap on total rows across every source. `0` = unlimited (internal safety cap of 50,000). |

### Output

Each row represents one event. Below is a representative payload (truncated for readability).

```json
{
  "eventId": "evt-7jzkcmnq",
  "eventUrl": "https://luma.com/7jzkcmnq",
  "name": "AI Founders Dinner — SF",
  "description": "An intimate dinner for AI founders building in production...",
  "startAt": "2026-06-12T01:00:00.000Z",
  "endAt": "2026-06-12T04:00:00.000Z",
  "timezone": "America/Los_Angeles",
  "coverUrl": "https://images.lumacdn.com/.../cover.jpg",
  "socialImage": "https://images.lumacdn.com/.../social.jpg",
  "eventType": "in_person",
  "categoryNames": ["AI", "Tech"],
  "location": {
    "name": "South Park Commons",
    "address": "529 Bryant St, San Francisco, CA 94107",
    "city": "San Francisco",
    "region": "California",
    "country": "United States",
    "latitude": 37.7811,
    "longitude": -122.3961,
    "isVirtual": false,
    "virtualProvider": null
  },
  "organizer": {
    "name": "Jane Doe",
    "slug": "janedoe",
    "profileUrl": "https://luma.com/user/janedoe",
    "avatarUrl": "https://images.lumacdn.com/.../avatar.jpg",
    "bio": "Investor at Acme Ventures, building AI tooling.",
    "socialHandles": {
      "twitter": "janedoe",
      "instagram": "jane.doe",
      "linkedin": "https://linkedin.com/in/janedoe",
      "youtube": null,
      "tiktok": null,
      "website": "https://janedoe.com"
    }
  },
  "hosts": [ { "name": "Jane Doe", "slug": "janedoe", "...": "..." } ],
  "featuredGuests": [ { "name": "Sam Speaker", "slug": "samspeaker", "...": "..." } ],
  "ticketing": {
    "isFree": false,
    "isSoldOut": false,
    "requiresApproval": true,
    "minPrice": 25.00,
    "maxPrice": 100.00,
    "currency": "USD",
    "spotsRemaining": 18,
    "guestCount": 42,
    "isNearCapacity": false
  },
  "ticketTypes": [
    { "name": "Early Bird", "price": 25.00, "currency": "USD", "available": false, "total": 20 },
    { "name": "Standard", "price": 100.00, "currency": "USD", "available": true, "total": 60 }
  ],
  "sessions": [
    { "name": "Opening remarks", "startAt": "2026-06-12T01:00:00.000Z", "endAt": "2026-06-12T01:15:00.000Z" }
  ],
  "registrationQuestions": [
    { "label": "Company", "type": "text", "required": true },
    { "label": "What are you building?", "type": "textarea", "required": false }
  ],
  "guestCount": 42,
  "locale": "en",
  "sourceUrl": "https://lu.ma/discover",
  "scrapedAt": "2026-05-16T14:32:11.421Z"
}
```

#### Core Fields

| Field | Type | Description |
|---|---|---|
| `eventId` | string | Luma's stable event identifier (`evt-...`). |
| `eventUrl` | string | Canonical event URL: `https://luma.com/<slug>`. |
| `name` | string | Event title. |
| `description` | string | Plain-text description (converted from Luma's rich-text format). |
| `eventType` | enum | `in_person`, `virtual`, or `hybrid`. |
| `categoryNames` | array of strings | Luma category labels attached to this event. |
| `locale` | string | Event language code. |
| `sourceUrl` | string | The URL or query you provided that produced this row. |
| `scrapedAt` | datetime | UTC timestamp the row was captured. |

#### Schedule & Location

| Field | Type | Description |
|---|---|---|
| `startAt` | datetime | Event start (UTC). |
| `endAt` | datetime | Event end (UTC). |
| `timezone` | string | IANA timezone (e.g. `America/Los_Angeles`). |
| `coverUrl` | string | Event cover image. |
| `socialImage` | string | Social-share image. |
| `location.name` | string | Venue or place name. |
| `location.address` | string | Full street address. |
| `location.city` | string | City. |
| `location.region` | string | State / region. |
| `location.country` | string | Country. |
| `location.latitude` | number | Latitude. |
| `location.longitude` | number | Longitude. |
| `location.isVirtual` | boolean | True for online events. |
| `location.virtualProvider` | string | Provider name for virtual events (when public). |

#### Ticketing

| Field | Type | Description |
|---|---|---|
| `ticketing.isFree` | boolean | Free event flag. |
| `ticketing.isSoldOut` | boolean | Sold-out flag. |
| `ticketing.requiresApproval` | boolean | Whether RSVPs need organizer approval. |
| `ticketing.minPrice` | number | Lowest ticket price (in dollars). |
| `ticketing.maxPrice` | number | Highest ticket price (in dollars). |
| `ticketing.currency` | string | ISO currency code. |
| `ticketing.spotsRemaining` | integer | Remaining capacity (when public). |
| `ticketing.guestCount` | integer | Confirmed RSVPs. |
| `ticketing.isNearCapacity` | boolean | Luma's near-capacity signal. |
| `ticketTypes[]` | array | Per-ticket type: `name`, `price`, `currency`, `available`, `total`. |

#### People

| Field | Type | Description |
|---|---|---|
| `organizer` | object | Primary organizer with name, slug, profile URL, avatar, bio, and social handles. |
| `hosts[]` | array | All listed hosts in the same person shape as `organizer`. |
| `featuredGuests[]` | array | Up to 10 featured guests with the same person shape (when `includeFeaturedGuests` is on). |
| `guestCount` | integer | Public confirmed-attendee count for the event. |

#### Sessions & Registration

| Field | Type | Description |
|---|---|---|
| `sessions[]` | array | Per-session blocks: `name`, `startAt`, `endAt`. |
| `registrationQuestions[]` | array | Public registration form fields: `label`, `type`, `required`. Answers are never public. |

### Tips for Best Results

- **Combine URLs and search queries.** A single run can mix a community calendar (`lu.ma/yc`), a city page (`lu.ma/sf`), and free-text queries (`["AI", "founders"]`) — all results land in one dataset.
- **Use `discoverCity` to defeat geo-bias.** Luma's discover feed weights results toward the requester's region. Explicitly setting a city slug delivers reliable, predictable coverage of that metro.
- **Lean on the `dateTo` early-stop.** Setting `dateTo` doesn't just filter — it tells the actor to stop paginating once the feed passes that date, dramatically cutting cost for short windows.
- **Turn off `scrapeEventDetails` for fast scans.** Listing-level fields (name, time, location, ticketing summary, organizer) are enough for many use cases and finish much faster than full-detail runs.
- **Set `includeFeaturedGuests` for prospecting.** Featured guests come with structured social handles — the cleanest path to identifying decision-makers attached to an event.
- **Power-user tip — use category pages for niches, search queries for broad sweeps.** Category slugs (`lu.ma/ai`, `lu.ma/crypto`) yield tightly-curated feeds; free-text queries cast a wider net but may surface lower-relevance matches. Mix both in the same run for full coverage of a topic.
- **Validate small first.** Run with `maxResults: 50` to confirm filters behave as expected, then scale up.

### Pricing

Pay-Per-Result: **$2.50 per 1,000 events**. No compute charges — you only pay per result returned. Filtered-out events (wrong category, outside your date range, wrong type, wrong pricing) are dropped before billing, so you never pay for rows you don't see.

| Events | Cost |
|---|---|
| 100 | $0.25 |
| 1,000 | $2.50 |
| 10,000 | $25.00 |
| 100,000 | $250.00 |

### Integrations

The Luma Event Scraper plugs into the entire Apify ecosystem:

- **Zapier** — push new events into Slack, Notion, Airtable, or HubSpot as they're discovered.
- **Make (Integromat)** — build multi-step workflows that enrich, route, and act on event data.
- **Google Sheets** — sync results into a live spreadsheet for non-technical teammates.
- **REST API** — call the actor from any backend and pull results from your dataset.
- **Webhooks** — get notified the moment a run finishes; trigger downstream pipelines automatically.
- **Apify Storage** — every run produces a structured dataset you can export to JSON, CSV, Excel, or XML with one click.

### Legal & Ethical Use

This actor extracts publicly available event data from Luma — the same information any user can see by visiting a Luma page in their browser. It does not access private events, organizer dashboards, attendee lists, or any login-gated content.

You are responsible for using the extracted data in compliance with Luma's terms of service, applicable data-protection laws (GDPR, CCPA, and equivalents), and the rights of the individuals named in the data. Personal information of organizers, hosts, and featured guests is sourced from their public profiles and should be treated with the same care you would apply to any public-facing personal data: avoid spam, respect opt-outs, and keep your outreach relevant and consensual.

# Actor input Schema

## `lumaUrls` (type: `array`):

Paste one or more Luma URLs. Accepts direct event pages (lu.ma/<event>), calendar or community pages (lu.ma/yc), city or place pages (lu.ma/sf), category pages (lu.ma/tech), the discover feed (lu.ma/discover), and user-profile pages (lu.ma/user/<name>). Mix any types in one list. If sources overlap (e.g. a city page plus a matching search query), each event is returned and billed only once.

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

Free-text queries to run against Luma's discover feed (e.g. 'AI Tokyo', 'Brooklyn music'). Each query runs independently. Leave empty if you only want to use URLs above. Events that also appear under another source are returned only once.

## `discoverCity` (type: `string`):

Optional. When set, every search query above runs scoped to this Luma city (e.g. 'san-francisco', 'nyc', 'london', 'tokyo'). Use the Luma city slug from the URL (lu.ma/<slug>). Leave empty to search globally.

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

Restrict discover and search results to a Luma category. 'All' disables the filter. Ignored when a URL already specifies a category.

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

Only include events starting on or after this date (YYYY-MM-DD). Leave empty for no lower bound.

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

Only include events starting on or before this date (YYYY-MM-DD). Leave empty for no upper bound.

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

Filter by in-person vs virtual events. Applied after results are fetched (Luma's API does not expose a server-side filter for this).

## `pricing` (type: `string`):

Filter by free vs paid events. Applied after results are fetched (Luma's API does not expose a server-side filter for this).

## `scrapeEventDetails` (type: `boolean`):

Fetch the full event payload for each result — description, ticket types, sessions, hosts with social handles, and public registration questions. Turn off for faster, lighter runs that return only the listing-level fields. Charged at the same per-result rate either way.

## `includeFeaturedGuests` (type: `boolean`):

When on, each event row carries Luma's public featured-guest list (up to 10 names per event). The full attendee list is never available — it requires the event organizer's login and is not part of Luma's public data.

## `maxEventsPerUrl` (type: `integer`):

Cap on events extracted per URL or per search query. Set to 0 for no per-source cap (the total maximum below still applies).

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

Hard cap on total event rows across every source. Use 0 for no cap — an internal safety limit of 50,000 still applies to prevent runaway pagination. The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots. Note: Luma's discover and category feeds are geo-biased and typically top out at a few hundred events per location — use specific cities or search queries to broaden coverage.

## Actor input object example

```json
{
  "lumaUrls": [
    "https://lu.ma/discover"
  ],
  "searchQueries": [],
  "category": "all",
  "eventType": "all",
  "pricing": "all",
  "scrapeEventDetails": true,
  "includeFeaturedGuests": false,
  "maxEventsPerUrl": 1000,
  "maxResults": 1000
}
```

# Actor output Schema

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

Table of scraped Luma events with the most useful columns.

# 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 = {
    "lumaUrls": [
        "https://lu.ma/discover"
    ],
    "searchQueries": [],
    "category": "all",
    "eventType": "all",
    "pricing": "all",
    "scrapeEventDetails": true,
    "includeFeaturedGuests": false,
    "maxEventsPerUrl": 1000,
    "maxResults": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "lumaUrls": ["https://lu.ma/discover"],
    "searchQueries": [],
    "category": "all",
    "eventType": "all",
    "pricing": "all",
    "scrapeEventDetails": True,
    "includeFeaturedGuests": False,
    "maxEventsPerUrl": 1000,
    "maxResults": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "lumaUrls": [
    "https://lu.ma/discover"
  ],
  "searchQueries": [],
  "category": "all",
  "eventType": "all",
  "pricing": "all",
  "scrapeEventDetails": true,
  "includeFeaturedGuests": false,
  "maxEventsPerUrl": 1000,
  "maxResults": 1000
}' |
apify call solidcode/luma-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Luma Event Scraper",
        "description": "[💰 $2.5 / 1K] Extract public events from Luma (lu.ma) — titles, dates, hosts, venues with coordinates, ticket prices, sold-out status, categories, and host social handles. Works on event pages, city/place pages, category pages, calendar/community pages, and the global discover feed.",
        "version": "1.0",
        "x-build-id": "PdKSgtOj76j5xirGa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~luma-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-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/solidcode~luma-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-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/solidcode~luma-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-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",
                "properties": {
                    "lumaUrls": {
                        "title": "Luma URLs",
                        "type": "array",
                        "description": "Paste one or more Luma URLs. Accepts direct event pages (lu.ma/<event>), calendar or community pages (lu.ma/yc), city or place pages (lu.ma/sf), category pages (lu.ma/tech), the discover feed (lu.ma/discover), and user-profile pages (lu.ma/user/<name>). Mix any types in one list. If sources overlap (e.g. a city page plus a matching search query), each event is returned and billed only once.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Free-text queries to run against Luma's discover feed (e.g. 'AI Tokyo', 'Brooklyn music'). Each query runs independently. Leave empty if you only want to use URLs above. Events that also appear under another source are returned only once.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "discoverCity": {
                        "title": "Restrict Search to a City",
                        "type": "string",
                        "description": "Optional. When set, every search query above runs scoped to this Luma city (e.g. 'san-francisco', 'nyc', 'london', 'tokyo'). Use the Luma city slug from the URL (lu.ma/<slug>). Leave empty to search globally."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "all",
                            "ai",
                            "tech",
                            "crypto",
                            "food",
                            "arts",
                            "climate",
                            "fitness",
                            "wellness"
                        ],
                        "type": "string",
                        "description": "Restrict discover and search results to a Luma category. 'All' disables the filter. Ignored when a URL already specifies a category.",
                        "default": "all"
                    },
                    "dateFrom": {
                        "title": "Earliest event date",
                        "type": "string",
                        "description": "Only include events starting on or after this date (YYYY-MM-DD). Leave empty for no lower bound."
                    },
                    "dateTo": {
                        "title": "Latest event date",
                        "type": "string",
                        "description": "Only include events starting on or before this date (YYYY-MM-DD). Leave empty for no upper bound."
                    },
                    "eventType": {
                        "title": "Event type",
                        "enum": [
                            "all",
                            "in_person",
                            "virtual"
                        ],
                        "type": "string",
                        "description": "Filter by in-person vs virtual events. Applied after results are fetched (Luma's API does not expose a server-side filter for this).",
                        "default": "all"
                    },
                    "pricing": {
                        "title": "Pricing",
                        "enum": [
                            "all",
                            "free",
                            "paid"
                        ],
                        "type": "string",
                        "description": "Filter by free vs paid events. Applied after results are fetched (Luma's API does not expose a server-side filter for this).",
                        "default": "all"
                    },
                    "scrapeEventDetails": {
                        "title": "Include full event details",
                        "type": "boolean",
                        "description": "Fetch the full event payload for each result — description, ticket types, sessions, hosts with social handles, and public registration questions. Turn off for faster, lighter runs that return only the listing-level fields. Charged at the same per-result rate either way.",
                        "default": true
                    },
                    "includeFeaturedGuests": {
                        "title": "Include featured guests",
                        "type": "boolean",
                        "description": "When on, each event row carries Luma's public featured-guest list (up to 10 names per event). The full attendee list is never available — it requires the event organizer's login and is not part of Luma's public data.",
                        "default": false
                    },
                    "maxEventsPerUrl": {
                        "title": "Maximum events per source",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on events extracted per URL or per search query. Set to 0 for no per-source cap (the total maximum below still applies).",
                        "default": 1000
                    },
                    "maxResults": {
                        "title": "Maximum results (total)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on total event rows across every source. Use 0 for no cap — an internal safety limit of 50,000 still applies to prevent runaway pagination. The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots. Note: Luma's discover and category feeds are geo-biased and typically top out at a few hundred events per location — use specific cities or search queries to broaden coverage.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
