# Luma Events Discovery Scraper (`automation-lab/luma-events-discovery-scraper`) Actor

🎟️ Discover public Luma events, calendars, organizers, public venues, schedules, and ticket availability by city, category, calendar, or event URL.

- **URL**: https://apify.com/automation-lab/luma-events-discovery-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/docs.md):

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

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

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

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

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

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

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

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

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


# README

## 🎟️ Luma Events Discovery Scraper

Discover and export public events from [Luma](https://luma.com) by city, category, calendar, community, or event URL.

Get clean event schedules, public venues, ticket and availability signals, calendar metadata, and public organizer profiles in one dataset. No Luma account or API key is required.

Use the Actor for local event newsletters, event aggregation, sponsorship research, organizer outreach, community monitoring, venue analysis, and recurring event intelligence.

### What does Luma Events Discovery Scraper do?

Luma Events Discovery Scraper turns public Luma discovery pages into structured records ready for JSON, CSV, Excel, APIs, webhooks, or downstream automations.

It supports five common workflows:

- 🌆 discover upcoming events from a public city page;
- 🧠 filter discovery by a Luma category such as AI, tech, crypto, or wellness;
- 📅 export upcoming or past events from a public calendar/community;
- 🎫 extract one individual public event;
- 🔎 combine several Luma URLs into one deduplicated dataset.

The Actor follows Luma's public web data layer and cursor pagination. It does not register for events, access host dashboards, or require private credentials.

### Who is this Luma event scraper for?

#### Event aggregators and newsletter teams

Refresh upcoming events for a city or topic, then publish selected records to a website, newsletter, or calendar feed.

#### Community and event marketers

Track active calendars, compare event cadence, and identify organizers running events in a relevant market.

#### Sponsors and partnership teams

Build prospect lists from public event and host profiles, public websites, and social handles without collecting attendee data.

#### Venue and local-market analysts

Map publicly disclosed venues and understand which categories are active in each city.

#### Data and product teams

Power event-discovery products, recommendation pipelines, dashboards, alerts, or research datasets through the Apify API.

### Why use this Actor?

- ⚡ **HTTP-first extraction** — no browser startup for the normal public route.
- 🔁 **Cursor pagination** — continues beyond the first page until your limit or source exhaustion.
- 🧹 **Automatic deduplication** — the same event from several inputs is saved and charged once.
- 🎯 **Flexible inputs** — event, calendar, city, category, and combined discovery pages.
- 🧾 **Normalized output** — one stable event schema across every supported source.
- 🔐 **Public-only boundary** — no attendee lists or authenticated host data.
- 📍 **Address safeguards** — registration-only addresses and restricted coordinates are omitted.
- 🛠️ **Apify integrations** — schedules, datasets, webhooks, API, Make, Zapier, n8n, and MCP.

### Supported Luma URLs

| Input type | Example | What it returns |
|---|---|---|
| City and category | `https://luma.com/discover/sf/ai` | Upcoming AI events around San Francisco |
| City | `https://luma.com/sf` | Upcoming public events in San Francisco |
| Category | `https://luma.com/ai` | Upcoming public AI events across discovery regions |
| Calendar/community | `https://luma.com/guides_` | Events from one public calendar |
| Individual event | `https://luma.com/vs5ybrec` | One public event with available detail |

Both `luma.com` and legacy `lu.ma` URLs are accepted and normalized.

Unsupported external hosts fail closed instead of being fetched as arbitrary URLs.

### How to scrape Luma events

1. Open the Actor's **Input** tab.
2. Add one or more public Luma URLs.
3. Set **Maximum events** to control dataset size and cost.
4. Optionally add date bounds.
5. For calendars, choose upcoming or past events.
6. Enable full event details only when you need descriptions and richer ticket context.
7. Click **Start**.
8. Open the **Dataset** tab to review or export the records.

Start with 10 events to validate your workflow, then increase the limit for scheduled production runs.

### Input parameters

| Field | Type | Default | Description |
|---|---|---:|---|
| `startUrls` | array | SF AI discovery | Public event, calendar, city, category, or discovery URLs |
| `maxItems` | integer | 25 | Maximum unique events across all inputs |
| `dateFrom` | string | — | Inclusive ISO lower bound; date-only values begin at 00:00:00 UTC |
| `dateTo` | string | — | Inclusive ISO upper bound; date-only values include the full UTC calendar day |
| `calendarPeriod` | string | `future` | `future` or `past` for calendar inputs |
| `enrichEventDetails` | boolean | `false` | Fetch one public detail response per event |
| `proxyConfiguration` | object | — | Optional Apify Proxy configuration |

Invalid dates, reversed date ranges, non-Luma URLs, and out-of-range limits produce an explicit failed run.

### Basic input example

```json
{
  "startUrls": [
    { "url": "https://luma.com/discover/sf/ai" }
  ],
  "maxItems": 25
}
````

### Calendar monitoring example

```json
{
  "startUrls": [
    { "url": "https://luma.com/guides_" }
  ],
  "maxItems": 100,
  "calendarPeriod": "future",
  "dateTo": "2026-09-30"
}
```

Run this input on a daily or weekly schedule and use event IDs to compare snapshots in your own database.

### Enriched sponsorship research example

```json
{
  "startUrls": [
    { "url": "https://luma.com/discover/sf/ai" },
    { "url": "https://luma.com/discover/nyc/tech" }
  ],
  "maxItems": 100,
  "enrichEventDetails": true
}
```

Detail enrichment can add descriptions, categories, counts, and richer public ticket context. It also adds one request per event, so leave it disabled when discovery-level fields are sufficient.

### What data can you extract?

| Field | Description |
|---|---|
| `eventId` | Stable public Luma event identifier |
| `eventUrl` | Canonical public event URL |
| `name` | Event name |
| `startAt`, `endAt` | ISO timestamps |
| `timezone` | Event IANA timezone |
| `eventType`, `visibility` | Public event state |
| `description` | Plain-text public description when enriched |
| `coverUrl`, `socialImageUrl` | Public event images |
| `location` | Location type and publicly disclosed venue/geography |
| `ticketing` | Free/paid, sold-out, capacity, approval, registration, and waitlist signals |
| `calendar` | Calendar/community identity, description, verification, and public links |
| `hosts` | Public host names, bios, verification, and social links |
| `categories` | Public Luma category names when enriched |
| `sourceUrl` | Input page that produced the event |
| `scrapedAt` | Extraction timestamp |

### Output example

```json
{
  "eventId": "evt-XG7GDKbx8VOdjGi",
  "eventUrl": "https://luma.com/vs5ybrec",
  "name": "Design & Deploy Workshop",
  "startAt": "2026-07-20T01:00:00.000Z",
  "endAt": "2026-07-20T04:00:00.000Z",
  "timezone": "America/Los_Angeles",
  "eventType": "independent",
  "visibility": "public",
  "location": {
    "type": "offline",
    "venueName": "Homebrew Club",
    "city": "San Francisco",
    "region": "California",
    "country": "United States",
    "latitude": 37.7881264,
    "longitude": -122.4053777,
    "addressVisibility": "public"
  },
  "ticketing": {
    "isFree": true,
    "soldOut": false,
    "requiresApproval": false,
    "registrationAvailability": "open",
    "waitlistEnabled": false
  },
  "calendar": {
    "id": "cal-TrbezBvP8Yt9MlF",
    "name": "Guides",
    "url": "https://luma.com/guides_",
    "verified": true
  },
  "hosts": [
    {
      "id": "usr-82lWli9unCprzqU",
      "name": "Saurabh K",
      "instagram": "https://instagram.com/saurabh_k_00000",
      "verified": false
    }
  ],
  "categories": [],
  "sourceUrl": "https://luma.com/discover/sf/ai",
  "scrapedAt": "2026-07-20T03:45:00.000Z"
}
```

Fields unavailable on a particular public page are omitted rather than invented.

### Venue and address privacy

Luma sometimes hides a venue until a guest registers or is approved.

When Luma marks an address as restricted or obfuscated, this Actor:

- keeps broad public geography such as city, region, and country;
- marks `addressVisibility` as `restricted`;
- omits the venue name and full address;
- omits latitude and longitude, even if an approximate internal coordinate is present.

The Actor never registers to unlock a location.

### Ticket and availability signals

Depending on the event and input route, `ticketing` can include:

- whether registration is free;
- minimum and maximum displayed price;
- sold-out and near-capacity state;
- remaining spots;
- whether host approval is required;
- registration availability;
- waitlist status;
- public aggregate guest and ticket counts.

These fields are observations, not a booking guarantee. Availability can change after the run completes.

### How much does it cost to scrape Luma events?

The Actor uses pay-per-event pricing:

- a small **$0.005 start fee** per run;
- one `item` event per unique event saved;
- tiered per-event pricing based on your Apify plan.

At the formula-derived BRONZE rate of $0.000093301 per event, 1,000 unique event records add about $0.0933 plus the start fee. The live Actor pricing table is authoritative and includes plan-based tier discounts.

Duplicate events are not charged twice in the same run. Runs that fail before valid extraction do not emit item charges.

### Pagination and limits

Discovery and calendar endpoints are paginated automatically.

`maxItems` is a run-wide limit, not a per-URL limit. If you provide three sources and set `maxItems` to 100, the Actor stops after 100 unique qualifying events total.

Date filters are applied before saving. A page can therefore be fetched even when all of its events are later excluded.

### Scheduling recurring monitors

For a recurring monitor:

1. save a task with stable discovery or calendar URLs;
2. keep a bounded `maxItems` appropriate for the source;
3. schedule the task daily or weekly;
4. send the dataset to your database or webhook;
5. key records by `eventId`;
6. compare `startAt`, venue, and ticketing fields to detect changes.

Apify schedules and webhooks make this workflow code-free.

### Export and integrations

Results can be exported as JSON, CSV, Excel, XML, RSS, or HTML.

Useful integration patterns include:

- **Google Sheets** — append a weekly local-event shortlist;
- **Airtable** — maintain an event sponsorship pipeline;
- **Make or Zapier** — notify a team when a matching event appears;
- **n8n** — enrich public organizer websites in a lead workflow;
- **Slack or email** — send a daily calendar digest;
- **BigQuery or Snowflake** — analyze event volume and venue trends;
- **webhooks** — trigger your application as soon as a run finishes.

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/luma-events-discovery-scraper').call({
  startUrls: [{ url: 'https://luma.com/discover/sf/ai' }],
  maxItems: 25,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/luma-events-discovery-scraper').call(run_input={
    'startUrls': [{'url': 'https://luma.com/discover/sf/ai'}],
    'maxItems': 25,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~luma-events-discovery-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url": "https://luma.com/discover/sf/ai"}],
    "maxItems": 25
  }'
```

After the run succeeds, read its `defaultDatasetId` from the run response and download the items through the Dataset API.

### Use with Apify MCP

Connect the Actor to AI assistants through [Apify MCP](https://mcp.apify.com/?tools=automation-lab/luma-events-discovery-scraper).

#### Claude Code setup

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com/?tools=automation-lab/luma-events-discovery-scraper"
```

#### Claude Desktop setup

Add this server to your Claude Desktop MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com/?tools=automation-lab/luma-events-discovery-scraper"
    }
  }
}
```

#### Cursor setup

Open **Cursor Settings → MCP**, add a server named `apify`, and use the same `mcpServers` JSON and URL shown above.

#### VS Code setup

Open your MCP server settings in VS Code, create an HTTP server named `apify`, and set its URL to the same actor-specific Apify MCP URL.

Example prompts:

- “Find the next 25 public AI events in San Francisco and group them by week.”
- “Export upcoming events from this Luma calendar and identify public organizer websites.”
- “Compare public ticket availability for these Luma event URLs.”
- “Create a sponsorship shortlist from public tech-event hosts in New York.”

### Tips for reliable runs

- Use canonical public Luma URLs copied from your browser.
- Start with 10–25 events before scaling a new workflow.
- Leave detail enrichment off when you only need discovery fields.
- Prefer city/category URLs over broad category-only inputs for local research.
- Use ISO date strings with an explicit timezone when hour-level boundaries matter.
- Add a proxy only after direct access shows repeatable rate limiting.
- Schedule moderate refresh intervals instead of repeatedly polling the same page.

### Limitations

- Luma can change its public web data layer without notice.
- Category-only discovery can reflect Luma's current geographic ranking.
- Some ticket fields only appear on enriched event details.
- Private events, guest-only venues, and authenticated calendars are outside scope.
- The Actor does not collect attendee lists or registration answers.
- Restricted virtual join links are not exposed.
- Results represent source state at extraction time.

### Troubleshooting

#### Why did my run fail with “Unsupported URL”?

Only HTTPS URLs on `luma.com` or `lu.ma` are accepted. Remove shortened links on other domains and copy the canonical public Luma URL.

#### Why are venue coordinates missing?

Luma marked the address restricted, guests-only, or obfuscated. The omission is intentional so the Actor does not leak registration-only location data.

#### Why did date filters return no records?

Confirm the dates are valid ISO values and that `dateFrom` is not later than `dateTo`. A date-only bound uses a UTC calendar day: `dateFrom` starts at 00:00:00 UTC and `dateTo` includes through 23:59:59.999 UTC. ISO date-times use their exact timestamp and offset. Calendar pages default to upcoming events; set `calendarPeriod` to `past` when needed.

#### Why is the description missing?

Enable **Fetch full event details**. Discovery pages often include enough schedule and organizer data but not the full public description.

#### What should I do about HTTP 403 or 429 errors?

Retry after a reasonable delay. If direct anonymous access is consistently limited, configure an Apify Proxy in the advanced input section.

### Is scraping public Luma data legal?

This Actor is designed for anonymously accessible public event metadata.

You are responsible for your use case, compliance with applicable law, Luma's terms, intellectual-property rights, privacy rules, and reasonable request rates. Do not use results for spam or intrusive profiling.

The Actor intentionally excludes private attendee lists, registration answers, authenticated host information, registration-only addresses, and restricted coordinates.

### Related event scrapers

- [Eventbrite Scraper](https://apify.com/automation-lab/eventbrite-scraper) — discover public Eventbrite listings and event details.
- [Meetup Scraper](https://apify.com/automation-lab/meetup-scraper) — collect public Meetup groups and events for community research.

Combine sources in your own database using source URLs and stable event identifiers.

### FAQ

#### Does this Actor require a Luma login?

No. The supported product scope uses public anonymous pages and data endpoints.

#### Can it scrape attendee or guest lists?

No. Attendee extraction is intentionally outside scope.

#### Can I scrape several cities in one run?

Yes. Add several city or city/category URLs to `startUrls`. `maxItems` applies across the whole run.

#### Does it support past events?

Yes for public calendar/community URLs by setting `calendarPeriod` to `past`. Discovery pages primarily expose upcoming events.

#### Are duplicates removed?

Yes. Events are deduplicated by stable Luma event ID within each run.

#### Can I fetch full ticket tiers and descriptions?

Enable `enrichEventDetails`. Availability varies by what each event publishes publicly.

#### Can I use the results commercially?

That depends on your jurisdiction, source terms, and use case. Obtain legal advice when needed and avoid spam or privacy-invasive processing.

#### How fresh is the data?

Each run requests the current public source. Use Apify schedules for recurring refreshes.

### Start building your Luma event dataset

Add a city/category page, keep the first run small, and export a clean dataset of public Luma events in minutes.

# Actor input Schema

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

Public Luma event, calendar/community, city, category, or city/category discovery URLs.

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

Maximum number of unique event records across all supplied pages.

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

Optional inclusive ISO date or date-time filter. Date-only values start at 00:00:00 UTC, for example 2026-07-20.

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

Optional inclusive ISO date or date-time filter. Date-only values include the full UTC calendar day, for example 2026-08-31.

## `calendarPeriod` (type: `string`):

Choose upcoming or past events when a calendar/community URL is supplied.

## `enrichEventDetails` (type: `boolean`):

Fetch each event page's public detail endpoint for descriptions, categories, ticket counts, and richer ticket context. This adds one request per event.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy settings. Direct anonymous access is used when omitted.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://luma.com/discover/sf/ai"
    }
  ],
  "maxItems": 10,
  "calendarPeriod": "future",
  "enrichEventDetails": false
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://luma.com/discover/sf/ai"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/luma-events-discovery-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": [{ "url": "https://luma.com/discover/sf/ai" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/luma-events-discovery-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": [
    {
      "url": "https://luma.com/discover/sf/ai"
    }
  ],
  "maxItems": 10
}' |
apify call automation-lab/luma-events-discovery-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Luma Events Discovery Scraper",
        "description": "🎟️ Discover public Luma events, calendars, organizers, public venues, schedules, and ticket availability by city, category, calendar, or event URL.",
        "version": "0.1",
        "x-build-id": "l4ilXCqzmO0mvs4AE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~luma-events-discovery-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-luma-events-discovery-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/automation-lab~luma-events-discovery-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-luma-events-discovery-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/automation-lab~luma-events-discovery-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-luma-events-discovery-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": "🎟️ Luma pages",
                        "type": "array",
                        "description": "Public Luma event, calendar/community, city, category, or city/category discovery URLs.",
                        "default": [
                            {
                                "url": "https://luma.com/discover/sf/ai"
                            }
                        ],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum events",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of unique event records across all supplied pages.",
                        "default": 25
                    },
                    "dateFrom": {
                        "title": "Start date from",
                        "type": "string",
                        "description": "Optional inclusive ISO date or date-time filter. Date-only values start at 00:00:00 UTC, for example 2026-07-20."
                    },
                    "dateTo": {
                        "title": "Start date to",
                        "type": "string",
                        "description": "Optional inclusive ISO date or date-time filter. Date-only values include the full UTC calendar day, for example 2026-08-31."
                    },
                    "calendarPeriod": {
                        "title": "Calendar event period",
                        "enum": [
                            "future",
                            "past"
                        ],
                        "type": "string",
                        "description": "Choose upcoming or past events when a calendar/community URL is supplied.",
                        "default": "future"
                    },
                    "enrichEventDetails": {
                        "title": "Fetch full event details",
                        "type": "boolean",
                        "description": "Fetch each event page's public detail endpoint for descriptions, categories, ticket counts, and richer ticket context. This adds one request per event.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Direct anonymous access is used when omitted."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```