# Luma Events Scraper - lu.ma Events, Hosts, Tickets & Organizers (`topapi/luma-events-scraper`) Actor

Scrape Luma (luma.com, lu.ma) events by city, category, keyword, calendar, host or link: every event near a city, hosts and organizers with socials, ticket prices, guest counts, full description, ticket types. Monitor mode, alerts. $0.027 per 1,000 events, details $0.69 per 1,000.

- **URL**: https://apify.com/topapi/luma-events-scraper.md
- **Developed by:** [Top Api](https://apify.com/topapi) (community)
- **Categories:** Lead generation, Social media, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 events

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Luma Events Scraper do?

**Luma Events Scraper** reads public events from [Luma](https://luma.com) (luma.com, formerly lu.ma) - the RSVP platform behind AI and tech meetups, hackathons, founder dinners, crypto and community events - and returns one row per event: name, link, start and end time with timezone, venue and address with coordinates, the organizer (calendar) with website and social links, every host and Luma's featured guests with their LinkedIn / Instagram / X / YouTube / TikTok links, ticket price, sold-out and waitlist state, spots left and the guest count. By default every row also carries the event's full Luma record: the description (text, Markdown and HTML), every ticket type with its price and spots, the registration questions, Luma categories, and the emails, phone numbers, Telegram / Discord / WhatsApp links and sponsor lines written in the description.

Luma scraper · lu.ma scraper · Luma events API · Luma calendar scraper · luma.com events data

- **Every event near a city, not only the city page:** Luma's own nearby feed. On 2026-11-06 it listed 1,065 events around San Francisco and 1,200 around London, against 77 and 62 on Luma's featured city pages (the featured page is one option away).
- **Every way into Luma:** cities (Luma's 87 cities or any other place name), Luma's 12 categories (in a city or worldwide), keyword search, calendars and communities (upcoming and past), hosts, event links, a point with a radius, a map rectangle, luma.com/discover - mixed in one run.
- **Past Luma's 50-match search cap:** a search near a city is read further by map area, a worldwide one region by region.
- **A date window that skips what you did not ask for:** the feed is opened at your start date instead of being paged through from today.
- **Organizer and host rows too:** one row per organizer calendar (website, socials, upcoming / past / last-90-day event counts) or per host profile (events hosted and attended, joined date) - and an optional email read from each organizer's own website.
- **Monitor mode with changes:** a schedule delivers only events earlier runs did not deliver, and (option) events whose date, price, sold-out or waitlist state, venue or format changed, with the old values. Alerts to a webhook, Slack, Discord, Teams, Telegram or ntfy; an .ics calendar file of the run.
- **No login, cookies or API key:** Luma's public JSON - the same data luma.com shows a visitor who is not signed in.
- **Pay only for delivered rows:** no start fee; filtered-out events, duplicates and events delivered by earlier monitor runs are never charged.

### What data can you get from Luma?

<table>
<tr>
<td>🎟️ Event name, id, link, slug</td>
<td>🗓️ Start, end, timezone, duration</td>
<td>🏷️ Luma categories, calendar tags</td>
</tr>
<tr>
<td>📍 Venue, full address, city, region, country</td>
<td>🗺️ Latitude / longitude, Google place id</td>
<td>💻 In person or online (Zoom, Google Meet ...)</td>
</tr>
<tr>
<td>🏢 Organizer: name, website, verified, Luma Plus</td>
<td>🔗 Organizer LinkedIn, Instagram, X, YouTube, TikTok</td>
<td>👤 Hosts with bio, website and social links</td>
</tr>
<tr>
<td>⭐ Featured guests (up to 10)</td>
<td>💳 Free / paid, price, currency, price range</td>
<td>🎫 Every ticket type: price, capacity, registered, spots</td>
</tr>
<tr>
<td>👥 Guest count, tickets, spots left</td>
<td>🚦 Open / waitlist / sold out, approval required</td>
<td>📝 Description: text, Markdown, HTML</td>
</tr>
<tr>
<td>❓ Registration questions</td>
<td>✉️ Emails, phones, Telegram / Discord links in the text</td>
<td>🤝 Sponsor and partner lines</td>
</tr>
</table>

Measured fill on a real 1,000-event London run (2026-11-06, details on): name, link, dates, city, country, coordinates, organizer, guest count, cover image and ticket types 100%; description 99.1%; hosts 98.3% (LinkedIn on 64.8% of hosts, website 33.8%, Instagram 30.2%, X 26.8%); Luma categories 75.8%; organizer social links 73.6%; spots remaining 67.8%; venue and full address 65.3% (the rest are events whose host shows the address to registered guests only - Luma then gives the city and an approximate point); registration questions 62.4%; featured guests 52.9%; organizer website 50.0%; links in the description 44.8%; sponsor lines 35.2%; paid events 23.4% (price and currency on those); Telegram / Discord / other social links in the description 17.3%; emails in the description 6.3%.

### How to scrape Luma with Luma Events Scraper

1. Type one or more **cities** (or pick **categories**, type **search keywords**, paste **calendars**, **hosts** or any **Luma links**).
2. Optional: a date window, in person / online, free / paid, a minimum guest count, words the event must or must not contain.
3. Leave **Full event details** on for descriptions and ticket types, or turn it off for listing rows only.
4. Click **Start**. Rows arrive in the dataset as each page is read; download them as JSON, CSV, Excel or XML.

### ⬇️ Input

| Field | What it does |
|---|---|
| `cities` | City names or Luma slugs (`San Francisco`, `sf`, `New York`, `London`, `Berlin`, `Tokyo`). Luma's 87 cities, or any other place name (found by a geocoder). |
| `categories` | `tech`, `ai`, `crypto`, `arts`, `food`, `climate`, `fitness`, `wellness`, `running`, `books`, `games`, `family`. With cities: that category in each city; without: worldwide, region by region. |
| `searchQueries` | Luma's own event search. Near each city when cities are given, otherwise worldwide. |
| `startUrls` | Any luma.com / lu.ma link: event, calendar, city page, category page, luma.com/discover, luma.com/user/... |
| `calendars` | Calendar slugs, links or `cal-` ids (`genai-sf`, `https://luma.com/ycombinator-official`). |
| `hosts` | Luma usernames, profile links or `usr-` ids. |
| `eventUrls` | Event links, slugs or `evt-` ids. |
| `urlsFromFile` | Many links or slugs, one per line. |
| `period` | Calendars and hosts: `upcoming` (default), `past`, `all`. |
| `cityScope` | `nearby` (default, every event near the city) or `featured` (Luma's curated city page). |
| `radiusKm` | Keep events within this distance of the city centre or the point. |
| `latitude`, `longitude` | Every event near a point. |
| `boundingBox` | Every event inside `{"north", "south", "east", "west"}`. |
| `dateFrom`, `dateTo`, `daysAhead` | Start-date window. |
| `eventType` | `any`, `in_person`, `online`. |
| `pricing` | `any`, `free`, `paid`. |
| `minGuests` | Minimum registered guests. |
| `keywordFilter`, `excludeKeywords` | Words the name (or, with details, the description) must / must not contain. |
| `hideSoldOut` | Drop sold-out events. |
| `includeDetails` | The full event record on every row (default on, charged per row that gets it). |
| `descriptionFormat`, `descriptionMaxLength` | `all` / `text` / `markdown` / `html`; cut length. |
| `includeHostProfiles` | Hosted / attended counts and join date on every host (no extra charge). |
| `organizerContacts` | Email, phones and social links from each organizer's own website (charged once per organizer per run, only when an email is found). |
| `outputType` | `events` (default), `calendars` (one row per organizer), `hosts` (one row per host), `all`. |
| `maxItems` | Rows in the run (default 100; 0 = no limit). |
| `maxItemsPerSource`, `maxPages` | Caps per city / category / search / calendar / host. |
| `splitSearches` | Read past Luma's 50-match search cap (default on). |
| `searchMatch` | `strict` (default): a search row must have a search word in its name, organizer or hosts. `luma`: Luma's own ranking as it is. |
| `monitorMode`, `emitChanges`, `monitorStoreName`, `firstRunMode`, `resetMonitor` | Scheduled runs: only new (and changed) events. |
| `generateIcs` | Save the delivered events as `events.ics`. |
| `webhookUrl` (+ `webhookHeaders`), `slackWebhookUrl`, `discordWebhookUrl`, `teamsWebhookUrl`, `telegramToken` + `telegramChatId`, `ntfyTopic` | Alerts after a run that delivered rows. |
| `maxConcurrency`, `proxyConfiguration` | Event records read at once; your own proxy (empty = direct, then Apify datacenter, then residential). |

Input names other Luma scrapers use are accepted too (`lumaUrls`, `discoverCity`, `slugs`, `scrapeEventDetails`, `maxResults`, `maxEvents`, `maxEventsPerCity`, `startDate` / `endDate`, `lat` / `lng`, `onlyNewItems`, `includePastEvents` ...).

#### Input JSON

```json
{
  "cities": ["San Francisco", "London"],
  "categories": ["ai"],
  "dateFrom": "2026-12-01",
  "dateTo": "2026-12-31",
  "pricing": "free",
  "minGuests": 50,
  "maxItems": 500
}
```

#### Tips

- **A whole city:** leave categories and keywords empty - the nearby feed is every public in-person event around it.
- **Online events:** Luma's city and map feeds list in-person events; online ones come from calendars, hosts, searches and links.
- **Big lists without descriptions:** turn **Full event details** off - listing rows still carry hosts, organizer, tickets and guest counts.
- **A worldwide search** ranks events near Luma's guess of the caller's location first; add cities for one area.

### ⬆️ Output

One row per event. A real row from the London run (trimmed: one host, one featured guest, one ticket type, descriptions cut):

```json
{
  "type": "event",
  "id": "evt-mXuRZDludSZQetj",
  "name": "Assay-A-Thon | Building an Experimental Validation Toolkit for AI-Enabled Discovery",
  "url": "https://luma.com/1a6mdyp6",
  "category": "ai",
  "categories": ["AI"],
  "startAt": "2026-11-06T17:00:00.000Z",
  "endAt": "2026-11-08T18:00:00.000Z",
  "timezone": "Europe/London",
  "durationMinutes": 2940,
  "locationType": "offline",
  "isOnline": false,
  "city": "London",
  "region": "England",
  "country": "United Kingdom",
  "countryCode": "GB",
  "latitude": 51.53056945427067,
  "longitude": -0.12524249328488116,
  "distanceKm": 2.4,
  "organizerName": "nile verleur",
  "organizerUrl": "https://luma.com/user/usr-o515DoAA4t7FrGS",
  "hosts": [
    {
      "id": "usr-o515DoAA4t7FrGS",
      "name": "nile verleur",
      "profileUrl": "https://luma.com/user/usr-o515DoAA4t7FrGS",
      "socialHandles": { "linkedin": "https://www.linkedin.com/in/nile-verleur", "instagram": null, "twitter": null, "youtube": null, "tiktok": null }
    }
  ],
  "hostCount": 4,
  "hostNames": "nile verleur, Inga Van den Bossche, Alex Ainscough, Anjali Chadha",
  "featuredGuestCount": 10,
  "ticketing": { "isFree": true, "isSoldOut": true, "spotsRemaining": 0, "requiresApproval": true, "registrationAvailability": "sold-out" },
  "guestCount": 46,
  "description": "Join us to develop prototypes and assays that meet the demands of AI-enabled discovery, then compete for a fellowship to experimentally validate your work using…",
  "ticketTypes": [{ "id": "ttype-kVlaaVAkvcJQTMm", "name": "Standard", "type": "free", "registered": 46, "requiresApproval": true }],
  "registrationQuestionCount": 10,
  "registrationQuestions": [{ "id": "tmsp7g5k", "label": "What is your LinkedIn profile?", "type": "linkedin", "required": true }],
  "detailsFetched": true,
  "source": "London",
  "sourceType": "city",
  "scrapedAt": "2026-11-06T20:38:21.034Z"
}
```

The full row also carries `location` (venue, full address, address, sublocality, place id, address visibility, meeting platform), `organizer` (id, slug, description, verified, Luma Plus, avatar, cover, website, social links), `featuredGuests`, `attendance` (tickets, waitlist, guest-list visibility), `descriptionMarkdown`, `descriptionHtml`, `descriptionLinks`, `extractedEmails`, `extractedPhones`, `socialLinks`, `sponsorMentions`, `nameRequirement`, `phoneRequirement`, `featuredIn`, `refundPolicy`, `coverImageUrl`, `socialImageUrl`, `dominantColors`, `featuredCity`, `tags` and `platform` (`external` for an event a calendar lists from another site). Monitor runs add `changeType`, `previousValues`, `firstSeenAt`, `lastSeenAt`, `contentHash`. The dataset has views for events, details, organizer leads, monitor changes, organizer calendars and hosts.

**Organizer rows** (`outputType: calendars`): id, name, slug, url, description, website, social links, city, country, coordinates, verified, Luma Plus, personal or community, total / upcoming / past / last-90-day events, next and last event, tags, membership tiers, Luma plan, and with organizer contacts the email, phones and website social links. **Host rows** (`outputType: hosts`): id, name, username, profile link, bio, website, social links, events hosted, events attended, joined date.

Not available: the guest / attendee list (Luma shows it only to signed-in users), and the exact address of events whose host keeps it for registered guests.

### How can I use Luma data?

- **Sales and partnerships:** organizers and hosts of AI, tech and founder events in a city, with their websites and LinkedIn - and the paid, near-capacity events worth sponsoring.
- **Event and community teams:** what competing communities run, when, at what price and how many people register.
- **Newsletters and event sites:** a daily feed of new events in a city or category, with descriptions and cover images.
- **Research:** event volume, pricing and attendance by city, category and month.

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

Pay per event, no start fee:

| What | Price |
|---|---|
| Event row | **$0.027 per 1,000** |
| Full event details on a row (default on) | **$0.69 per 1,000** |
| Organizer calendar row | $6.30 per 1,000 |
| Host profile row | $5.40 per 1,000 |
| Organizer email from their website | $0.90 per 1,000 organizers with an email |

A detailed event row is $0.717 per 1,000; a listing row alone $0.027 per 1,000. Measured on real runs: 20 events with details $0.014; 150 events across three cities $0.11; 1,000 London events with details $0.72 (130 s); 3,000 listing rows from three cities $0.081 (46 s). Set **Maximum cost per run** in the run options and the run stops cleanly at it (a $0.02 limit delivered 27 detailed events and charged $0.0194).

### Run it on a schedule (only new events)

Turn on **Only new events (monitor)** and schedule the actor (Apify Console > Schedules, or the API). The first run delivers what it finds (or, with **First monitor run: remember only**, nothing); every later run with the same input delivers only events it has not delivered before. With **Also changed events**, a remembered event whose name, date, price, sold-out or waitlist state, venue or format changed comes back as `changeType: "updated"` with `previousValues`. Turn on event details, host profiles or organizer contacts later and the events delivered without them come back once with them (`changeType: "details"`), charged like any delivered event. A poll that finds nothing costs about $0.0001 of platform time and is not charged.

```json
{
  "cities": ["Toronto"],
  "maxItems": 0,
  "monitorMode": true,
  "emitChanges": true,
  "slackWebhookUrl": "https://hooks.slack.com/services/..."
}
```

Measured: first run 430 events; an immediate second poll 0 rows ($0.000096); a poll 20 minutes later 1 new event and 2 changed ones (one sold out, one renamed).

### Integrations, API, scheduling & MCP

Run it from the Apify API (`POST https://api.apify.com/v2/acts/TopApi~luma-events-scraper/runs`), the Apify CLI, Make, Zapier, n8n, Google Sheets, or an AI agent through the Apify MCP server. Results stay in the run's dataset (JSON, CSV, Excel, XML, RSS); `events.ics` imports into Google, Outlook and Apple Calendar.

### Limits & empty runs

- Luma answers about 50 feed pages from one IP in a burst, then asks for "additional verification". The actor reads up to 40 pages at once per egress, then one every 3 seconds, and moves one rung up (direct, then Apify datacenter, then residential) when Luma asks - so very large runs slow down rather than stop: 3,671 tech events worldwide took 204-224 s.
- A search shows Luma's 50 best matches. Luma answers even a word no event uses with 50 unrelated events; in `strict` mode those rows are dropped, the run ends with a status that says so, and nothing is charged.
- City, map and category feeds list upcoming in-person events; past events come from calendars and hosts (`period`).
- An event whose full record cannot be read is delivered with its listing fields (`detailsFetched: false`) and is not charged for details.
- Every 0-row run ends with a status that says why (nothing matched the filters, a link that is not on Luma, a search word no event has); nothing is charged.

### FAQ

#### How many events can I get in one run?

As many as Luma lists: a whole city's nearby feed (London 1,200, San Francisco 1,065, Toronto 430 on 2026-11-06), every city in a list, a category worldwide (tech: 3,671), or a calendar's full history.

#### Do I need a Luma account, cookies or an API key?

No. Everything comes from Luma's public pages and JSON, as a signed-out visitor sees them.

#### Can I get the attendee list?

No. Luma shows the guest list only to signed-in users; the actor delivers the public guest count and Luma's featured guests.

#### Can I get the organizer's email?

Turn on **Organizer email from their website**: the actor reads the organizer's own website (the link on their Luma calendar) and its contact / about pages. Emails written in the event description are in `extractedEmails` on every detailed row.

#### How do I get only events I have not seen?

Monitor mode (above).

#### Why did my run return no results?

The status message says why: the filters removed every event, the city is not found, the link is not a Luma page, or Luma's search has no event with the word. Nothing is charged for an empty run.

#### Your feedback

Found a Luma page the actor does not read, or need a field? Open an issue on the actor's Issues tab.

# Actor input Schema

## `cities` (type: `array`):

City names or Luma city slugs: "San Francisco", "sf", "New York", "London", "Berlin", "Tokyo". Any of Luma's 87 cities, or any other place name (found by a geocoder). By default every public event near the city is read, not only Luma's featured city page.

## `categories` (type: `array`):

Luma's 12 categories. With cities: that category in each city. Without a city: the category across every Luma city.

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

Luma's own event search, e.g. "hackathon", "ai agents", "founders dinner". With cities: near each city; without: worldwide. Luma shows 50 matches per search; the run reads on by map area (near a city) or city by city (worldwide) when you want more.

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

Any luma.com or lu.ma link, mixed: event pages (luma.com/abc123), calendars and communities (luma.com/genai-sf), city pages (luma.com/sf), category pages (luma.com/tech), luma.com/discover, host profiles (luma.com/user/name).

## `calendars` (type: `array`):

Calendar slugs, links or ids, e.g. "genai-sf", "https://luma.com/ycombinator-official", "cal-JTdFQadEz0AOxyV". Upcoming events by default; see Period.

## `hosts` (type: `array`):

Luma usernames, profile links (luma.com/user/name) or usr- ids: the events each host runs.

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

Event links, slugs ("8v9rokfj") or evt- ids. Each comes with its full event record.

## `urlsFromFile` (type: `string`):

Paste many Luma links or slugs, one per line.

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

For calendars and hosts. City, category and search feeds list upcoming events only.

## `cityScope` (type: `string`):

Nearby: every public in-person event Luma lists around the city (San Francisco 1,065, London 1,200 on 2026-11-06). Featured: the curated city page (77 and 62).

## `radiusKm` (type: `integer`):

Keep events within this distance of the city centre or of the point below. 0 = Luma's own area (about 50 km).

## `latitude` (type: `number`):

Every event near a point (with longitude), e.g. 51.5072.

## `longitude` (type: `number`):

With latitude, e.g. -0.1276.

## `boundingBox` (type: `object`):

Every event inside a map rectangle: {"north": 51.7, "south": 51.3, "east": 0.2, "west": -0.5}.

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

Only events starting on or after this date (YYYY-MM-DD). The feed is opened at this date, so earlier events are never read.

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

Only events starting on or before this date. Reading stops past it.

## `daysAhead` (type: `integer`):

Only events in the next N days (7 = this week).

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

Luma's city and map feeds list in-person events; online events come from calendars, hosts, searches and links.

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

Free or paid registration.

## `minGuests` (type: `integer`):

Only events with at least this many registered guests (Luma's public guest count).

## `keywordFilter` (type: `array`):

Keep events whose name (or description, with details on) contains any of these words.

## `excludeKeywords` (type: `array`):

Drop events whose name or description contains any of these words.

## `hideSoldOut` (type: `boolean`):

Drop events Luma marks sold out.

## `includeDetails` (type: `boolean`):

Each event's full record: description (text, Markdown, HTML), every ticket type with price and spots, registration questions, categories, contacts and sponsor lines written in the description. Charged per row that gets it. Off = listing rows only.

## `descriptionFormat` (type: `string`):

Which description fields each detailed row carries.

## `descriptionMaxLength` (type: `integer`):

Cut descriptions to this many characters. 0 = full.

## `includeHostProfiles` (type: `boolean`):

Add each host's hosted and attended event counts and Luma join date to the hosts on every row (one look-up per host, no extra charge).

## `organizerContacts` (type: `boolean`):

Read the organizer's own website (the link on their Luma calendar): homepage, then contact / about pages, for an email, phones and social links. Charged once per organizer per run, only when an email is found.

## `outputType` (type: `string`):

Organizer rows: name, website, socials, event counts (upcoming, past, last 90 days). Host rows: profile, socials, hosted and attended counts.

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

Rows in this run, over all sources (events, or organizers / hosts in those modes). 0 = no limit.

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

Cap per city, category, search, calendar or host. 0 = no cap.

## `maxPages` (type: `integer`):

50 events a page. 0 = no cap.

## `splitSearches` (type: `boolean`):

A search that shows 50 matches is read further by map area (near a city) or city by city (worldwide) when the run wants more rows.

## `searchMatch` (type: `string`):

Luma's search always answers with 50 events, even for a word no event uses. Strict drops the ones without the word (before any charge).

## `maxConcurrency` (type: `integer`):

Event records read at once.

## `monitorMode` (type: `boolean`):

Each run delivers (and charges) only events earlier runs with the same input have not delivered. Pairs with a daily schedule.

## `emitChanges` (type: `boolean`):

With monitor on: also deliver remembered events whose name, date, price, sold-out or waitlist state, venue or format changed (changeType "updated", with previousValues).

## `monitorStoreName` (type: `string`):

Keeps separate memories for separate schedules. Empty = one memory per input.

## `firstRunMode` (type: `string`):

What the first monitor run does.

## `resetMonitor` (type: `boolean`):

Forget what earlier runs delivered (one run).

## `generateIcs` (type: `boolean`):

Also save the delivered events as events.ics in the run's key-value store (Google, Outlook, Apple Calendar).

## `webhookUrl` (type: `string`):

POST the new rows here after the run (n8n, Make, Zapier).

## `webhookHeaders` (type: `object`):

Extra headers for the webhook, e.g. {"Authorization": "Bearer ..."}.

## `slackWebhookUrl` (type: `string`):

Slack incoming-webhook URL.

## `discordWebhookUrl` (type: `string`):

Discord webhook URL.

## `teamsWebhookUrl` (type: `string`):

Teams incoming-webhook URL.

## `telegramToken` (type: `string`):

Your Telegram bot token (with the chat id below).

## `telegramChatId` (type: `string`):

The chat, group or channel to message.

## `ntfyTopic` (type: `string`):

Push to an ntfy.sh topic (or your own server below).

## `ntfyServer` (type: `string`):

Default https://ntfy.sh.

## `notificationLimit` (type: `integer`):

How many events each alert lists.

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

Empty = direct, then Apify datacenter, then Apify residential if Luma shows a challenge page. Your own proxy goes first.

## Actor input object example

```json
{
  "cities": [
    "San Francisco"
  ],
  "period": "upcoming",
  "cityScope": "nearby",
  "eventType": "any",
  "pricing": "any",
  "hideSoldOut": false,
  "includeDetails": true,
  "descriptionFormat": "all",
  "includeHostProfiles": false,
  "organizerContacts": false,
  "outputType": "events",
  "maxItems": 20,
  "splitSearches": true,
  "searchMatch": "strict",
  "maxConcurrency": 10,
  "monitorMode": false,
  "emitChanges": false,
  "firstRunMode": "emitAll",
  "resetMonitor": false,
  "generateIcs": false,
  "notificationLimit": 10
}
```

# Actor output Schema

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

One item per event (or per organizer calendar / host in those modes): name, link, dates, location, organizer, hosts, featured guests, tickets, guest counts and, with details, the description, ticket types and registration questions.

## `calendarFile` (type: `string`):

The delivered events as an iCalendar file (only with the calendar-file option on).

## `summary` (type: `string`):

Per-source counts (read, delivered, pages), filters, detail look-ups and egress (written for Console runs, large runs and runs with a problem).

# 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 = {
    "cities": [
        "San Francisco"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("topapi/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 = {
    "cities": ["San Francisco"],
    "maxItems": 20,
}

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

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

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

```

## CLI example

```bash
echo '{
  "cities": [
    "San Francisco"
  ],
  "maxItems": 20
}' |
apify call topapi/luma-events-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,topapi/luma-events-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/4cygMmNdFbINpAWY6/builds/CrETQdV740IsIax36/openapi.json
