# Luma Event Scraper - lu.ma Events, Hosts & Calendars (`haketa/luma-event-scraper`) Actor

Luma (lu.ma) event scraper & API: discover events by city or category, scrape calendars and export name, date, venue & GPS, tickets, guest counts and host social profiles. Event discovery, sponsorship research and creator lead generation — fast, no login.

- **URL**: https://apify.com/haketa/luma-event-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Lead generation, Business
- **Features:** Limited permissions
- **Stats:** 77 total users, 9 monthly users, 100.0% runs succeeded, 1 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Luma Event Scraper 🎟️ — Scrape lu.ma Events, Hosts, GPS & Calendars

**Extract Luma ([lu.ma](https://lu.ma/) / [luma.com](https://luma.com/)) events as clean, structured data — no login, no coding.** This **Luma scraper** lets you **discover events by city or category**, scrape entire **calendars and communities**, or pull **individual events**, returning full details: **event name, ISO dates & timezone, venue address, GPS coordinates, ticket availability & pricing, guest counts, and host/organizer social profiles**. Point it at a city, a topic, or any `luma.com` URL and get a spreadsheet-ready dataset in seconds.

Export to **JSON, CSV, Excel, XML, or API**.

> 💡 **Two core strengths:** (1) **City & category discovery** — list every upcoming event in SF, NYC, London, Berlin, Singapore, Tokyo, and 20+ global hubs with automatic deep pagination (`1,000+` events supported). (2) **Host & organizer lead generation** — every event includes its organizers' **Instagram, X/Twitter, LinkedIn, TikTok, YouTube, and website** so you can **scrape Luma** for B2B sponsorship, partnership, and creator outreach lists.

> Built for **event marketers, community builders, B2B sponsors, venues, sales/BD teams, researchers, and data/AI teams** who need live, structured event intelligence from **Luma**.

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue)](https://apify.com/haketa/luma-event-scraper)
[![Live Data](https://img.shields.io/badge/Data-Live%20at%20Run%20Time-orange)]()
[![Scale](https://img.shields.io/badge/Scale-1%2C000%2B%20Events%20Pagination-brightgreen)]()
[![Proxy](https://img.shields.io/badge/Proxy-Datacenter%20Supported-success)]()
[![No Auth](https://img.shields.io/badge/Authentication-None%20Required-success)]()
[![Exports](https://img.shields.io/badge/Export-JSON%20%7C%20CSV%20%7C%20Excel%20%7C%20API-informational)]()

***

### ⚡ At a glance

| Feature | Details |
|---|---|
| **Target Platform** | Luma (`lu.ma` / `luma.com`) — global event, meetup, conference & community platform |
| **Discovery Modes** | 4 combinable modes: **27 Built-in Cities** + custom city slugs, **8 Categories** (`ai`, `tech`, `crypto`, `arts`, `food`, `climate`, `fitness`, `wellness`), **Community Calendars**, and **Direct URLs** |
| **Core Event Data** | Event ID, Name, Slug, URL, Start/End ISO Timestamps, Timezone, Venue Address, City/Region/Country, GPS Latitude/Longitude, Cover & Social Images |
| **Demand & Ticketing** | Free/Paid flag, Price & Max Price, Sold-Out flag, Near-Capacity signal, Spots Remaining, Approval Required, Guest Count, Ticket Capacity |
| **Organizer Lead-Gen** | Host Name, Username, Website, Bio, Verified Badge, Avatar, **Instagram, X/Twitter, LinkedIn, TikTok, YouTube** handles + Owning Calendar URL |
| **Deep Detail Mode** | Optional `includeDetails: true` adds full plain-text **Event Description**, itemized **Ticket Types/Prices**, and **Category Tags** |
| **Pagination & Scale** | Automatic multi-page cursor traversal & multi-city scaling (`1,000+` unique events per run), 100% deduplicated by `eventId` |
| **Speed & Cost** | High-speed HTTP extraction on standard **Apify Datacenter Proxy** — ~100–500 events in 5–25 seconds |

***

### 📋 Table of contents

- [Why scrape Luma?](#-why-scrape-luma)
- [What this Luma scraper does](#-what-this-luma-scraper-does)
- [High-value use cases](#-use-cases)
- [Input configuration](#-input)
- [Output data & field reference](#-output)
- [Host & organizer lead generation](#-host--organizer-lead-generation)
- [Pagination & 1,000+ event scaling](#-pagination--scale)
- [How to use (Console & API)](#️-how-to-use)
- [Pro tips & best practices](#-tips)
- [Frequently asked questions](#-faq)
- [Related event & B2B scrapers](#-related-scrapers)
- [Changelog](#-changelog)

***

### 🔎 Why scrape Luma?

[Luma (lu.ma)](https://lu.ma/) powers tens of thousands of tech meetups, AI hackathons, startup mixers, venture capital summits, conferences, creator workshops, and community gatherings worldwide. It has become the default RSVP and ticketing platform for technology, AI, web3, design, climate, and founder ecosystems — making it one of the richest public sources of **who is hosting what, where, when, and for how many attendees**.

However, Luma offers no public bulk export and no open discovery feed. If you want *"every upcoming AI and tech event in San Francisco, New York, and London"* or *"every organizer hosting 100+ guest events this quarter with their LinkedIn and X handles"*, manual copying across infinite-scroll pages is slow and misses structured fields like GPS coordinates, capacity signals, and organizer social links.

This **Luma event scraper** automates the entire workflow and delivers a clean, normalized dataset ready for your CRM, spreadsheet, or data warehouse.

**Common reasons teams scrape Luma:**

- 📇 **B2B organizer & host lead generation** — extract event hosts with their websites and social profiles (**LinkedIn, X/Twitter, Instagram, YouTube, TikTok**) for sponsorship, venue sales, catering, dev-tools advocacy, and partnership outreach.
- 🌆 **City-wide event aggregation** — track every upcoming event in San Francisco, New York, London, Berlin, Los Angeles, Austin, Singapore, Tokyo, Dubai, and 20+ other cities.
- 🏷️ **Topic & vertical monitoring** — filter to `ai`, `tech`, `crypto`, `climate`, `arts`, `food`, `fitness`, or `wellness` across one or many cities at once.
- 📅 **Community & ecosystem tracking** — monitor specific Luma calendars/communities on a schedule and alert your team when new events are announced.
- 📊 **Turnout & demand intelligence** — benchmark `guestCount`, `ticketCount`, `isNearCapacity`, `isSoldOut`, and `isFree` vs. paid ticket tiers.
- 🗺️ **Geospatial mapping** — plot events by exact `latitude` and `longitude` for conference side-event maps, hotel/venue demand modeling, and field-marketing planning.
- 🤖 **Event newsletters, directories & AI agents** — feed curated community calendars, Slack/Discord bots, and recommendation engines with live structured event data.

***

### ✨ What this Luma scraper does

Combine four flexible discovery modes in a single run:

- 🌆 **Scrape Luma by city** — choose from 27 top global event cities in the dropdown (`sf`, `nyc`, `la`, `london`, `berlin`, `paris`, `amsterdam`, `lisbon`, `barcelona`, `munich`, `austin`, `miami`, `chicago`, `seattle`, `boston`, `denver`, `toronto`, `mexico-city`, `buenos-aires`, `singapore`, `bengaluru`, `mumbai`, `bangkok`, `tokyo`, `sydney`, `dubai`, `nairobi`), plus add any other Luma city slug via `citiesCustom`.
- 🏷️ **Scrape Luma by category** — filter by `tech`, `ai`, `crypto`, `arts`, `food`, `climate`, `fitness`, or `wellness` — either combined with cities or across all of Luma.
- 📅 **Scrape Luma calendars & communities** — extract every upcoming event from specific Luma community calendars by handle (e.g. `vizcom`).
- 🔗 **Scrape Luma by direct URL** — paste any `luma.com` or `lu.ma` link (individual event, community calendar, or city page); the scraper automatically detects the page type and extracts it.
- 🔁 **Deep pagination & 1,000+ scaling** — traverses every page of results automatically and scales across cities to deliver `1,000+` deduplicated events when requested.

***

### 🎯 Use cases

#### 1. Sponsorship, DevRel & partnership outreach

Developer-tool companies, cloud providers, API startups, and brand sponsors filter Luma for `ai` and `tech` events across major hubs, then export the `hosts[]` array to reach active community organizers directly via LinkedIn, X/Twitter, Instagram, or their company website.

#### 2. Venue, catering & event-production sales

Event spaces, coworking operators, AV production firms, and corporate caterers identify high-frequency local organizers (`calendarName`, `hostCount`, `guestCount`) hosting offline events in their city.

#### 3. Conference side-event & ecosystem mapping

During major tech weeks (SF Tech Week, NY Tech Week, Token2049, ETHDenver, Web Summit Lisbon), growth teams and media publishers aggregate every independent side event with exact start/end times, venue addresses, and `latitude`/`longitude` coordinates to publish interactive side-event maps.

#### 4. Newsletter curation & local media directories

City guides, Substack writers, and industry communities schedule weekly runs to auto-populate *"Upcoming Events This Week"* digests complete with registration links (`url`), cover images (`coverUrl`), and sold-out/waitlist badges.

#### 5. Venture capital & startup intelligence

VC platform and scout teams monitor founder, AI, and hacker communities across SF, NYC, London, and Bengaluru to spot emerging organizer hubs and high-demand technical gatherings (`isNearCapacity`, `guestCount`).

***

### 📥 Input

Every input field is optional — run with the default prefill for an instant San Francisco sample, leave everything empty for a multi-city mix, or combine cities, categories, calendars, and URLs.

| Field | Type | Default / Prefill | Description |
|---|---|---|---|
| `cities` | array (select) | `["sf"]` | Select one or more cities from 27 global hubs (`sf`, `nyc`, `la`, `london`, `berlin`, `paris`, `amsterdam`, `lisbon`, `barcelona`, `munich`, `austin`, `miami`, `chicago`, `seattle`, `boston`, `denver`, `toronto`, `mexico-city`, `buenos-aires`, `singapore`, `bengaluru`, `mumbai`, `bangkok`, `tokyo`, `sydney`, `dubai`, `nairobi`). |
| `category` | string (select) | `""` (Any) | Filter events by category: `""` (Any), `tech`, `ai`, `crypto`, `arts`, `food`, `climate`, `fitness`, `wellness`. |
| `citiesCustom` | array (string) | `[]` | Advanced: extra city slugs not in the dropdown (the slug in `luma.com/<slug>`, e.g. `"helsinki"`, `"zurich"`, `"seoul"`). |
| `calendars` | array (string) | `[]` | Advanced: Luma calendar/community handles to scrape all upcoming events from (e.g. `"vizcom"`). |
| `startUrls` | array | `[]` | Advanced: any `luma.com` or `lu.ma` URLs — individual events, calendar pages, or city pages. Auto-detected. |
| `includeDetails` | boolean | `false` | Fetch each event's individual detail page to add full `description`, `ticketTypes` (with prices/currencies/capacities), and `categories`. Keep `false` for fast, low-cost runs. |
| `maxItems` | integer | `0` (prefill `100`) | Maximum number of events to extract (`0` = unlimited; `1,000+` supported). |
| `proxyConfiguration` | object | `{ "useApifyProxy": true }` | Proxy configuration. Standard **Apify Datacenter proxy** works out of the box. |
| `maxConcurrency` | integer | `5` | Maximum parallel requests (`1`–`20`). |

#### Example 1 — AI & Tech events across major startup hubs (1,000+ scale)

```json
{
  "cities": ["sf", "nyc", "london", "berlin", "singapore", "austin", "toronto"],
  "category": "ai",
  "includeDetails": false,
  "maxItems": 1000
}
```

#### Example 2 — Scrape a community calendar with full descriptions & ticket tiers

```json
{
  "calendars": ["vizcom"],
  "includeDetails": true,
  "maxItems": 200
}
```

#### Example 3 — Specific event & city URLs

```json
{
  "startUrls": [
    { "url": "https://luma.com/dm9hcg5q" },
    { "url": "https://luma.com/sf" }
  ],
  "includeDetails": true,
  "maxItems": 100
}
```

***

### 📤 Output

Each dataset item represents one Luma event with complete timing, location, demand, calendar, and organizer metadata.

#### Sample output record

```json
{
  "eventId": "evt-eTDsO4hyMOktJs4",
  "name": "Make Your Own Perfume",
  "slug": "dm9hcg5q",
  "url": "https://luma.com/dm9hcg5q",
  "eventType": "independent",
  "visibility": "public",
  "startAt": "2026-11-03T02:30:00.000Z",
  "endAt": "2026-11-03T04:00:00.000Z",
  "timezone": "America/Los_Angeles",
  "locationType": "offline",
  "isOnline": false,
  "address": "The Love Potion Library - Books, Tea, Wine",
  "fullAddress": "The Love Potion Library - Books, Tea, Wine, 284 Noe St, San Francisco, CA 94114, USA",
  "city": "San Francisco",
  "region": "California",
  "country": "United States",
  "latitude": 37.7645596,
  "longitude": -122.4334143,
  "virtualUrl": null,
  "coverUrl": "https://images.lumacdn.com/uploads/ni/84db688e-d62e-402b-8885-b88433d7003b.jpg",
  "socialImageUrl": "https://images.lumacdn.com/event-social/0n/d5ac6599-8e2b-47d1-9c5f-1c7538f660c5.png",
  "isFree": false,
  "price": null,
  "maxPrice": null,
  "isSoldOut": true,
  "isNearCapacity": false,
  "spotsRemaining": 0,
  "requireApproval": false,
  "registrationAvailability": "waitlist",
  "guestCount": 19,
  "ticketCount": 25,
  "calendarName": "Eau Yeah!",
  "calendarSlug": "eauyeah",
  "calendarUrl": "https://luma.com/eauyeah",
  "calendarApiId": "cal-c0cPHOm1TDnFRNW",
  "hosts": [
    {
      "name": "Tony S.",
      "username": "tonyseb",
      "website": "https://eauyeah.example.com",
      "bio": "Founder & Perfumer at Eau Yeah!",
      "avatarUrl": "https://images.lumacdn.com/uploads/sb/cf921698-cbbe-4ef9-b0cf-a8e5c924e5ad.jpg",
      "isVerified": false,
      "instagram": "tonyseb9",
      "twitter": null,
      "linkedin": "in/tonyseb",
      "tiktok": null,
      "youtube": null
    }
  ],
  "hostCount": 3,
  "featuredGuestCount": 0,
  "scrapedAt": "2026-11-10T02:00:00.000Z"
}
```

#### Field reference & coverage

##### 🗓️ Identity, Timing & Media Fields

| Field | Type | Coverage | Description |
|---|---|---|---|
| `eventId` | string | 🟢 High (100%) | Unique Luma event ID (`evt-...`), used for cross-page and cross-city deduplication. |
| `name` | string | 🟢 High (100%) | Full event title. |
| `slug` | string | 🟢 High (100%) | Luma URL slug. |
| `url` | string | 🟢 High (100%) | Full canonical event URL (`https://luma.com/<slug>`). |
| `eventType` | string | 🟢 High (100%) | Event classification (e.g. `independent`, `session`). |
| `visibility` | string | 🟢 High (100%) | Visibility state (`public`, `private`). |
| `startAt` | string | 🟢 High (100%) | Event start timestamp (ISO 8601 UTC). |
| `endAt` | string | 🟢 High (100%) | Event end timestamp (ISO 8601 UTC). |
| `timezone` | string | 🟢 High (100%) | Event local IANA timezone (e.g. `America/Los_Angeles`, `Europe/London`). |
| `coverUrl` | string|null | 🟢 High (~100%) | High-resolution event cover image URL. |
| `socialImageUrl` | string|null | 🟢 High (~99%) | OpenGraph / social share preview image URL. |
| `scrapedAt` | string | 🟢 High (100%) | ISO 8601 extraction timestamp. |

##### 📍 Venue, Geography & GPS Fields

| Field | Type | Coverage | Description |
|---|---|---|---|
| `locationType` | string | 🟢 High (100%) | `offline` (in-person) or `online` (virtual). |
| `isOnline` | boolean | 🟢 High (100%) | `true` when the event is virtual/online. |
| `address` | string|null | 🟢 High (~92%) | Venue name or primary street address (for in-person events). |
| `fullAddress` | string|null | 🟡 Conditional (~75%) | Complete street address (populated when not hidden behind RSVP approval). |
| `city` | string|null | 🟢 High (~99%) | Event city name. |
| `region` | string|null | 🟢 High (~95%) | State, province, or region. |
| `country` | string|null | 🟢 High (~100%) | Country name. |
| `latitude` | number|null | 🟢 High (~98%) | Venue GPS latitude coordinate. |
| `longitude` | number|null | 🟢 High (~98%) | Venue GPS longitude coordinate. |
| `virtualUrl` | string|null | 🟡 Conditional | Online join link (populated only for online events that expose a public link). |

##### 🎟️ Ticketing, Capacity & Demand Signals

| Field | Type | Coverage | Description |
|---|---|---|---|
| `isFree` | boolean | 🟢 High (100%) | Whether the event offers free registration. |
| `price` | number|null | 🟡 Conditional | Base ticket price (populated on paid events that display pricing publicly). |
| `maxPrice` | number|null | 🟡 Conditional | Highest tier ticket price. |
| `isSoldOut` | boolean | 🟢 High (100%) | `true` when tickets are completely sold out. |
| `isNearCapacity` | boolean | 🟢 High (100%) | Demand signal indicating the event is close to capacity. |
| `spotsRemaining` | integer|null | 🟡 Conditional | Remaining capacity count when published by the organizer. |
| `requireApproval` | boolean | 🟢 High (100%) | `true` when guest registration requires manual host approval. |
| `registrationAvailability` | string|null | 🟢 High (~95%) | Current registration status (e.g. `available`, `waitlist`, `sold_out`). |
| `guestCount` | integer|null | 🟢 High (~100%) | Publicly visible attendee/guest count (`0` when hidden by host). |
| `ticketCount` | integer|null | 🟢 High (~100%) | Total tickets issued or capacity count. |

##### 👥 Organizers, Hosts & Detail Enrichments

| Field | Type | Coverage | Description |
|---|---|---|---|
| `calendarName` | string|null | 🟢 High (100%) | Name of the owning Luma calendar or community. |
| `calendarSlug` | string|null | 🟢 High (~95%) | Handle/slug of the owning calendar. |
| `calendarUrl` | string|null | 🟢 High (~95%) | Direct URL to the community calendar (`https://luma.com/<calendarSlug>`). |
| `calendarApiId` | string|null | 🟢 High (100%) | Unique Luma calendar ID (`cal-...`). |
| `hosts` | array | 🟢 High (~98%) | Array of organizer objects (`name`, `username`, `website`, `bio`, `avatarUrl`, `isVerified`, `instagram`, `twitter`, `linkedin`, `tiktok`, `youtube`). |
| `hostCount` | integer | 🟢 High (100%) | Number of hosts attached to the event. |
| `featuredGuestCount` | integer | 🟢 High (100%) | Number of featured VIP guests listed. |
| `description` | string|null | 🟡 Detail Mode (`includeDetails`) | Full plain-text event description from the detail page. |
| `ticketTypes` | array | 🟡 Detail Mode (`includeDetails`) | Itemized ticket tiers (`{ name, price, currency, maxCapacity, isHidden }`). |
| `categories` | array | 🟡 Detail Mode (`includeDetails`) | Topic tags (`{ slug, name }`) attached to the event. |

***

### 📣 Host & organizer lead generation

Every event record includes the full **`hosts[]` array** with each organizer's public social and web footprint:

- **Name & Username** (`name`, `username`)
- **Company / Personal Website** (`website`)
- **Short Bio & Verified Status** (`bio`, `isVerified`)
- **5 Social Handles:** `linkedin`, `twitter` (X), `instagram`, `youtube`, and `tiktok`

In a 500-event verification run across major cities, **97.8%** of events included host profiles (over **1,040 organizer records**), with LinkedIn (~59%), Instagram (~46%), and X/Twitter (~32%) frequently populated. Combine city + category filters (e.g. `cities: ["sf", "nyc", "london"]`, `category: "ai"`) to build high-converting B2B outreach lists of active community leaders in seconds.

***

### 🔁 Pagination & scale

- **Automatic multi-page cursor pagination:** Every city discovery feed and community calendar is traversed page by page until all upcoming events are collected or your `maxItems` target is reached.
- **1,000+ event scaling across cities:** When you request a large dataset (e.g. `maxItems: 1000` or `0` for unlimited), the scraper automatically paginates across your selected cities — and if a single city exhausts its upcoming events before reaching your `maxItems` target, it seamlessly expands across Luma's 27 global hubs so your run reaches 1,000+ events without stopping early.
- **Strict deduplication (`0%` duplicates):** Every event is deduplicated in memory by `eventId` across all pages, cities, categories, and calendars in the run.

***

### ⚙️ How to use

1. Open **Luma Event Scraper** in the Apify Console and click **Try for free**.
2. Pick one or more **Cities** from the 27-city dropdown (or add custom slugs under **More cities**).
3. Optionally choose a **Category** (`ai`, `tech`, `crypto`, etc.) or paste **Calendars** / **Luma URLs**.
4. Set **Max events** (`100` for a quick test, `1000` or `0` for deep extraction).
5. Enable **Include full event details** only if you need full text descriptions and itemized ticket tiers.
6. Click **Start** and download your dataset in **JSON, CSV, Excel, XML, or via REST API**.

#### Call via Python API

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("haketa/luma-event-scraper").call(run_input={
    "cities": ["sf", "nyc", "london", "berlin"],
    "category": "ai",
    "includeDetails": False,
    "maxItems": 500,
})

for event in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(event["name"], event["startAt"], event["city"], len(event["hosts"]))
```

***

### 💡 Tips

- **Keep `includeDetails: false` for fast discovery & lead-gen:** Core fields — including GPS coordinates, guest counts, ticket flags, calendar links, and all host social profiles — are already extracted in fast discovery mode without needing individual event fetches.
- **Add any global city via `citiesCustom`:** Simply copy the slug from `luma.com/<slug>` (e.g. `seoul`, `taipei`, `warsaw`, `madrid`) into `citiesCustom`.
- **Filter hosts for outreach:** Export to CSV or Excel and filter for rows where `hosts/0/linkedin`, `hosts/0/twitter`, or `hosts/0/website` is non-empty.
- **Schedule recurring runs:** Use Apify Schedules to monitor newly announced events and track `guestCount`, `isNearCapacity`, and `isSoldOut` changes over time.

***

### ❓ FAQ

**How many events can I scrape in a single run?**
There is no hard cap — set `maxItems` to `1000`, `5000`, or `0` (unlimited) and the scraper paginates through all available pages and cities automatically.

**Do I need a Luma account, API key, or residential proxies?**
No. No login or API key is required, and the default **Apify Datacenter proxy** works reliably out of the box.

**Does the scraper extract organizer contact and social profiles?**
Yes. Every event includes the `hosts[]` list with each organizer's `name`, `website`, `bio`, and handles for **LinkedIn, X/Twitter, Instagram, YouTube, and TikTok** whenever published on their Luma profile.

**Can I scrape a specific community calendar or single event URL?**
Yes. Add calendar handles to `calendars` (e.g. `["vizcom"]`) or paste full `luma.com` event/calendar URLs into `startUrls`.

**When should I turn on `includeDetails`?**
Turn on `includeDetails: true` when you need the full multi-paragraph `description`, itemized `ticketTypes` (with per-tier price and capacity), and `categories`. Leave it `false` for maximum speed.

***

### 🔗 Related scrapers

Building an event intelligence or B2B outreach pipeline? Pair this **Luma scraper** with other actors by **haketa**:

- 🎟️ [Meetup Scraper](https://apify.com/haketa/meetup-scraper) — extract Meetup groups, events, attendee counts, venues, and organizers.
- 🎫 [Eventbrite Scraper](https://apify.com/haketa/eventbrite-scraper) — scrape Eventbrite events, dates, venues, organizers, and ticket prices.
- 📬 [Email & Contact Extractor](https://apify.com/haketa/email-extractor) — feed organizer `website` URLs from Luma into this extractor to harvest direct email addresses and phone numbers.
- 🏨 [Expedia Scraper](https://apify.com/haketa/expedia-scraper) — hotel rates and availability around major conferences and event dates.

***

### 📋 Changelog

- **v1.2 (2026-11)** — Added in-memory `eventId` deduplication across pages, cities, and calendars (`0%` duplicates); unlocked automatic multi-city scaling across all 27 Luma hubs when `maxItems` exceeds single-city inventory (`1,000+` events supported); enhanced documentation with field coverage tables.
- **v1.1 (2026-06)** — Added `includeDetails` enrichment for ProseMirror plain-text descriptions, itemized ticket tiers, and category tags.
- **v1.0 (2026-04)** — Initial release supporting Luma city discovery, category filtering, calendar scraping, and organizer social profile extraction.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/luma-event-scraper/changelog.md

# Actor input Schema

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

Pick one or more cities to discover upcoming events in. Leave everything empty and the scraper returns a fresh mix of events from top event cities automatically.

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

Only return events in this category. Choose 'Any category' to include everything. Works with the cities above or on its own.

## `citiesCustom` (type: `array`):

Optional. Add extra cities not in the list above using their Luma slug (the last part of luma.com/<slug>), e.g. 'helsinki' or 'nashville'. Most users can skip this and just use the Cities dropdown.

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

Optional. Scrape every upcoming event from specific Luma calendars or communities by their handle (the last part of luma.com/<handle>), e.g. 'vizcom'.

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

Optional. Paste any luma.com links — individual events, calendar pages, or city pages. Each type is detected automatically. Combined with the fields above.

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

Fetch each event's full detail page to add the description, ticket types/prices and categories. Turn off for faster, cheaper runs (all core fields are still included).

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

Maximum number of events to scrape. Use 0 for no limit.

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

Proxy settings for the run. The default works well.

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

Maximum parallel requests.

## Actor input object example

```json
{
  "cities": [
    "sf"
  ],
  "category": "",
  "includeDetails": false,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 5
}
```

# Actor output Schema

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

All events collected during the run.

## `runUrl` (type: `string`):

Open this run in the Apify Console.

# 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": [
        "sf"
    ],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/luma-event-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": ["sf"],
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/luma-event-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": [
    "sf"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/luma-event-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/luma-event-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/YaDCczmWopeg9pAy9/builds/1HidSCyGrpd9xwjYS/openapi.json