# Luma Scraper — Events, Hosts, Socials & Tickets (lu.ma) (`logiover/luma-scraper`) Actor

Luma (lu.ma / luma.com) events scraper: every upcoming event in any city or country, categories, keyword search, calendars with past events, hosts. Dates, venue, coordinates, prices, ticket types, guest counts, organiser and host socials (X, LinkedIn, Instagram, website). No login.

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

## Pricing

from $1.70 / 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 Scraper

**Export events from Luma (luma.com, formerly lu.ma) as clean, analysis-ready data — every upcoming event in a city, region, country or the whole world, Luma's categories and keyword search, any organiser's calendar with its past events, any host's events — with dates and time zones, venues and coordinates, prices and ticket types, registration status and guest counts, and the websites, LinkedIn, X (Twitter), Instagram, YouTube and TikTok profiles of the calendars and hosts behind each event.**

**Luma Scraper** is a fast, reliable **Luma API alternative** for anyone who needs **Luma event data** at scale: **scrape lu.ma and luma.com events** without a login, without cookies and without a browser, and **export Luma events to CSV, Excel or JSON**, Google Sheets or your own database. Use it as a **Luma events scraper** for one city ("every tech event in San Francisco next week"), as a **Luma calendar scraper** that pulls an organiser's complete history (the Latent.Space calendar alone lists 308 events, 303 of them past), as a **Luma host scraper** for lead generation, or as a **global event dataset** builder — the whole Luma map held **20,319 upcoming in-person events in 133 countries on 2026-10-20**, and one run exported all of them with **0 duplicates**. It covers **AI events, tech meetups, startup events, hackathons, founder dinners, crypto and web3 events, run clubs, wellness, art and book clubs** — everything people publish on Luma.

Every row is one Luma event: name, Luma event id and link, start and end in UTC **and** in the event's local time zone, duration, in-person or online (Zoom, Google Meet, YouTube …), venue name, full address, neighbourhood, city, region, country and **coordinates** — or, when the organiser shows the address only to registered guests, the city with Luma's approximate pin and a clear `addressHidden` flag. Then the business side: **free or paid, price and currency, every ticket type with its price, capacity and sales window, approval required, waitlist, sold out, spots left, guest count ("N Going")**, the registration questions the organiser asks, the full **description** as clean text with all its links and the lines that **mention sponsors and partners**, Luma's **categories**, and where Luma features the event. Finally the people: the **calendar (organiser)** with its website and social profiles, and **every host** with name, Luma profile, bio, website, **X (Twitter), LinkedIn, Instagram, YouTube and TikTok** — optionally with how many events each host has organised and attended. Searching for a *Luma Veranstaltungen Scraper*, a way to *extraer eventos de Luma a Excel*, *exporter les événements Luma en CSV* or a *Luma イベント 一覧* export? This is the tool.

> Independent tool. Not affiliated with, endorsed by, or sponsored by Luma AI, Inc. (luma.com). "Luma" is a trademark of its owner and is used here only to describe the website this Actor reads.

***

### Table of contents

1. [At a glance](#at-a-glance)
2. [What you get](#what-you-get)
3. [Who uses it — and how](#who-uses-it--and-how)
4. [How it works](#how-it-works)
5. [Cookbook: ready-to-run inputs](#cookbook-ready-to-run-inputs)
6. [Tutorial: your first run in the Apify Console](#tutorial-your-first-run-in-the-apify-console)
7. [Tutorial: run it through the API](#tutorial-run-it-through-the-api)
8. [Input reference](#input-reference)
9. [Output data dictionary](#output-data-dictionary)
10. [Output example](#output-example)
11. [Scale, speed and coverage](#scale-speed-and-coverage)
12. [What you pay](#what-you-pay)
13. [Integrations](#integrations)
14. [Performance tips](#performance-tips)
15. [Troubleshooting](#troubleshooting)
16. [Limits](#limits)
17. [Compared with the other ways to get Luma data](#compared-with-the-other-ways-to-get-luma-data)
18. [FAQ](#faq)
19. [Glossary](#glossary)
20. [Legal and data protection](#legal-and-data-protection)
21. [Changelog](#changelog)
22. [Support](#support)

***

### At a glance

| | |
|---|---|
| **Source** | luma.com (lu.ma) — public event pages, calendars, profiles and Luma's event map |
| **Coverage** | Every upcoming in-person event on Luma's map — **20,319 events in 133 countries and 156 time zones** on 2026-10-20 — plus the upcoming **and past** events (online and in-person) of any calendar or host |
| **Fields per event** | 74 columns: event, time, place, description, categories, prices, ticket types, registration, calendar with socials, hosts with socials |
| **Ways to choose events** | Locations (Luma's 87 cities, any city, region or country, coordinates, a map box, "everywhere"), Luma's 12 categories, keyword search, calendars, hosts, any luma.com link, Luma's featured picks |
| **Filters** | Upcoming / past / both (calendars and hosts), start date range, in person / online, free / paid |
| **Speed (measured)** | First rows in about a second; **1,000 events with full details in 50 s**; the whole Luma map (20,319 events) in 22 minutes |
| **De-duplication** | By Luma event id across every source in a run — 0 duplicates in the 20,319-event run |
| **Accuracy (measured)** | 29 events checked field by field against the live luma.com pages: 796 of 799 values identical — the other 3 were guest counts that changed between scraping and checking |
| **Output** | Apify dataset → JSON, CSV, Excel, XML, RSS, HTML table; API; integrations |
| **Login / cookies / browser** | None needed |
| **Price** | Fixed price per event saved, from **$1.70 per 1,000 events** — compute and proxies included |

***

### What you get

Real values from runs on 2026-10-20. Every field, with type and measured fill rate, is in the [data dictionary](#output-data-dictionary).

**The event**

- `id` — `"evt-kEEwMQEK7LOx4Xj"` (Luma's event id; stable, used for de-duplication)
- `url` — `"https://luma.com/zbp6a1e1"` (the public event page; old lu.ma links redirect there)
- `name` — `"SGLang Meetup with LinkedIn and LMCache"`
- `description` — the full "About Event" text as clean text, bullets and line breaks kept
- `descriptionLinks` — every link in the description
- `sponsorMentions` — the description lines that name sponsors or partners, verbatim: `"Long Horizon After Party | Hosted by Encord, sponsored by CoreWeave & LanceDB"`, `"SPONSORS: Office of Economic Workforce Development | Grants For The Arts | Yerba Buena CBD"`
- `categories` — Luma's own categories: `["AI"]`, `["Arts & Culture", "Climate"]`
- `featuredIn` — Luma city pages and community calendars that feature the event: `["San Francisco"]`
- `coverImageUrl` — the event's cover image

**When**

- `startAt` / `endAt` — `"2026-10-21T00:00:00.000Z"` (UTC, ISO 8601)
- `timezone` — `"America/Los_Angeles"`
- `startAtLocal` / `endAtLocal` — `"2026-10-20T17:00:00-07:00"` (the time the page shows, with its UTC offset)
- `durationMinutes` — `240`; `timeStatus` — `"upcoming"`, `"ongoing"` or `"ended"`

**Where**

- `locationType` — `"offline"` (in person), `"zoom"`, `"meet"`, `"youtube"` …; `isOnline` — `false`
- `venueName` — `"LinkedIn Corporation - Building 950 (LSNR)"`
- `address` — `"LinkedIn Corporation - Building 950 (LSNR), 950 W Maude Ave, Sunnyvale, CA 94085, USA"`; `shortAddress` — `"950 W Maude Ave, Sunnyvale"`
- `neighborhood` — `"Sunnyvale West"`, `city` — `"Sunnyvale"`, `region` — `"California"`, `country` — `"United States"`, `countryCode` — `"US"`
- `latitude` / `longitude` — `37.39245` / `-122.0412877`; `googlePlaceId` — `"ChIJGVicMwC3j4AREcC64ZSIxbg"`
- `addressHidden` — `true` when the organiser shows the address only to registered or approved guests (20.2 % of events on the map). Such rows still carry the neighbourhood, city, region and country, and Luma's approximate pin (`coordinatesApproximate: true`); the street address is never guessed.
- `locationNote` — the organiser's own note on the location ("Take the lift. Go to level 4!")

**Tickets and registration**

- `isFree` — `true`; `price` — `0` (for paid events Luma's summary price, tax included, e.g. `20` with `currency` `"GBP"`); `maxPrice` — the dearest ticket; `minPrice` — the minimum of a pay-what-you-want ticket; `priceIsFlexible`
- `taxName` / `taxPercent` — `"VAT"` / `20` when the organiser charges tax at checkout
- `ticketTypes` — every ticket: name, type (`free`, `fiat-price` …), price, currency, capacity, registered, spots remaining, approval, hidden, sold out or closed, sales start and end, description
- `registrationStatus` — what the registration card says: `"open"`, `"waitlist"`, `"sold-out"`, `"closed"` or `"coming-soon"`
- `requiresApproval` — `true` (the host approves every guest — 37.3 % of map events); `isSoldOut`, `waitlistActive`, `isNearCapacity`
- `guestCount` — `277` (the page's "277 Going"); `spotsRemaining` and `capacity` when the organiser set a limit
- `registrationQuestions` — the questions asked at registration; the most common on Luma: "What is your LinkedIn profile?" (2,282 events of 20,319) and "What company do you work for?" (2,175)
- `refundPolicy` — the organiser's refund terms

**The organiser (calendar)**

- `calendarName` — `"SGLang Meetups and Events"`, `calendarUrl` — `"https://luma.com/SGLang"`, `calendarId`
- `calendarDescription`, `calendarWebsite` — `"https://sglang.io/"`
- `calendarTwitter`, `calendarLinkedin`, `calendarInstagram`, `calendarYoutube`, `calendarTiktok` — full profile URLs
- `calendarCity`, `calendarCountryCode`, `calendarAvatarUrl`, `calendarIsPersonal` (a person's own calendar rather than a community or company)

**The hosts**

- `hostNames` — `"LMSYS Org | Qing Lan | Sundara Raman Ramachandran"`, `hostCount` — `3`
- `hosts` — for each host: `name`, `username`, `url` (Luma profile), `bio`, `avatarUrl`, `website`, `twitter`, `linkedin`, `instagram`, `youtube`, `tiktok`, `isVerified`, and with *Add host profile numbers* also `eventsHosted`, `eventsAttended`, `joinedAt`

**Run metadata**

- `platform` — `"luma"` (or `"external"` for events a calendar lists from another site), `source` — which of your inputs found the row, `detailsIncluded`, `scrapedAt`

***

### Who uses it — and how

#### Event sponsors and B2B marketers

Sponsoring the right meetups is cheaper than any ad. Run a city or category every Monday, filter `categories` and `guestCount`, read `sponsorMentions` to see which brands already sponsor similar events, and contact the organiser through `calendarWebsite` and `calendarLinkedin` or the hosts' LinkedIn profiles. 55.6 % of events on the map have at least one host with a LinkedIn profile.

#### Developer relations and community teams

Map every AI, developer or data meetup in your target cities, see who organises them (`calendarName`, `hosts`), how big they get (`guestCount`, `capacity`) and which venues host them (`venueName`, `googlePlaceId`). Pick co-hosting partners and speaking slots with data instead of guesswork.

#### Venture capital and AI-ecosystem trackers

A weekly `categories: ["ai"]` + `locations: ["everywhere"]` export shows where the AI community meets, which companies host (`hostNames`, `bio`) and which events fill up (`registrationStatus: "waitlist"`). Calendars of accelerators and communities with `when: "all"` give you their complete event history.

#### Sales teams running event-led growth

Hosts are founders, community leads and operators. Filter events by category and city, de-duplicate `hosts` by `id`, and you have a lead list with LinkedIn, X and websites — plus context for the first message ("saw you host the Agent Builders Hackathon").

#### Event agencies, venues and coworking spaces

Which venues are booked for which kinds of events, how often, at what ticket prices? `venueName`, `address`, `googlePlaceId`, `neighborhood`, `price` and `guestCount` per city answer it. Venues find organisers who are still looking for a space.

#### Recruiters and talent teams

Hackathons, demo days and technical meetups are where engineers show up. Search `"hackathon"` across your cities, export the hosts (often the hiring managers and founders) and the dates, and plan sourcing around them.

#### Startup founders and community builders

Benchmark your own events: ticket prices (`ticketTypes`), approval and waitlist use, typical guest counts and questions asked in your city and category. Find the communities you should co-host with.

#### Market researchers and analysts

The whole Luma map in one dataset: events per city and country, free vs paid (79.2 % free on 2026-10-20), price levels by currency (USD, EUR, GBP, CAD, JPY …), category mix, approval rates, time-of-day patterns from `startAtLocal`. Repeat it weekly for a time series.

#### Newsletters, media and city guides

"What's on this weekend in Berlin" in one run: `locations: ["Berlin"]` with a `startDate`/`endDate` window. Clean descriptions, cover images and links make the issue quick to write.

#### Event discovery apps and aggregators

Sync Luma events into your app or website: stable `id`, `url`, coordinates, local times with offsets, cover images, prices and registration state. Schedule a daily run and upsert by `id`.

#### Universities, student clubs and career services

Collect campus-area, career and founder events for students — a small `radiusKm` around the campus, or the club calendars directly.

#### Event-platform and ticketing analysts

Measure Luma adoption: 13,290 calendars published map events on 2026-10-20; see how many are paid, in which currencies, and which features (approval, waitlists, flexible prices, tax) organisers use.

#### Influencer and creator marketing

Hosts with Instagram, TikTok and YouTube profiles who run in-person events are natural partners for brand activations. Filter `hosts` by those fields and by category (Fitness, Wellness, Arts & Culture, Food & Drink).

#### AI, RAG and LLM pipelines

Descriptions come as clean text (no HTML), with links extracted and every field typed — ready for embeddings, classification or an agent that recommends events. 97–98 % of events have a description.

***

### How it works

Luma's own website reads its events from a public JSON interface. Luma Scraper reads the same interface, the way luma.com itself does, without a browser:

1. **Locations, categories and the whole map.** Luma's map answers "the upcoming in-person events inside this box", soonest first, 50 per page. A city becomes a circle of `radiusKm`; a region or country its OpenStreetMap boundary. Large areas are read in cells of at most 10 × 10 degrees, because Luma answers bigger boxes only approximately (a 15 × 60-degree box returned 93 % of its events); "everywhere" and countries as big as the United States are read through Luma's whole-map list and filtered. Long lists are read in several time windows at once, and every event is checked against your area before it is saved.
2. **Keyword search.** Luma's search is semantic: "hackathon" also finds "buildathon" and "hack night". It answers the 50 best matches per area. Luma Scraper keeps Luma's own answer for each area, and where that answer is full **and** still mostly mentions your term it zooms into smaller boxes and keeps the events that mention it — so busy cities are searched completely without drowning you in loosely related events.
3. **Calendars and hosts.** A calendar's upcoming and/or past events and a host's events are read page by page — online and in-person.
4. **Links.** Any luma.com or lu.ma link is recognised: event pages, calendars, city pages, category pages, profiles.
5. **Details.** For every event, Luma's event record adds the description, categories, ticket types, registration questions, refund policy and where Luma features it (on by default). *Add host profile numbers* reads each host's profile once.
6. **De-duplication and filters.** Every event is saved once (by Luma event id), however many of your sources find it; date, in-person/online and price filters apply to every source.

The scraper paces itself to Luma's limits (measured 2026-10-20: about 49 map requests a minute per address; event records clean at 10–30 per second): about 1.5 map pages and 15 event records per second, direct connection first, Apify datacenter proxies when Luma asks a shared address to slow down.

***

### Cookbook: ready-to-run inputs

All recipes were run on 2026-10-20; the numbers are what they returned.

#### 1. Every upcoming event in a city

```json
{ "locations": ["San Francisco"], "maxItems": 1000 }
```

A 50 km circle around San Francisco (Oakland, Palo Alto, Mountain View, Sunnyvale) — the radius luma.com itself searches. 1,000 events in 49.1 s. Use `"radiusKm": 15` for the city only.

#### 2. One category in a city

```json
{ "locations": ["New York"], "categories": ["ai"], "maxItems": 100 }
```

AI events in and around New York: 100 events in 2.9 s.

#### 3. A whole country

```json
{ "locations": ["Germany"], "maxItems": 2000 }
```

Germany's boundary, every event inside it (checked by Luma's country code). 1,289 German events were on the map on 2026-10-20.

#### 4. One category everywhere

```json
{ "locations": ["everywhere"], "categories": ["crypto"], "maxItems": 1000 }
```

Crypto events worldwide, soonest first. Categories alone (without locations) also cover the whole map.

#### 5. A keyword in several cities

```json
{ "searchTerms": ["hackathon"], "locations": ["San Francisco", "New York", "London"], "maxItems": 500 }
```

Luma's search plus the zoom-in on busy cities. In San Francisco and Germany 71 of 88 results mentioned "hackathon" in the title; the rest are Luma's own closest matches ("buildathon", "hack night").

#### 6. A calendar's full history

```json
{ "calendars": ["https://lu.ma/ls"], "when": "all", "maxItems": 0 }
```

Every upcoming and past event of the Latent.Space calendar: 308 events (5 upcoming, 303 past), online and in person.

#### 7. Everything a host organises, with profile numbers

```json
{ "hosts": ["https://luma.com/user/lmsys"], "when": "all", "includeHostProfiles": true }
```

27 events hosted by LMSYS Org, and for every co-host how many events they host and attend.

#### 8. A list of event links

```json
{ "urls": ["https://luma.com/zbp6a1e1", "evt-tkyaOUQSVvrjGQ3", "https://lu.ma/sologpsummit"] }
```

Refresh events you already know: 3 rows in 2.3 s.

#### 9. Next week in a city

```json
{ "locations": ["London"], "startDate": "2026-10-21", "endDate": "2026-10-27", "maxItems": 1000 }
```

Only events that start between the two dates (events already running on the first day are kept).

#### 10. Free events only

```json
{ "locations": ["Berlin"], "price": "free", "maxItems": 500 }
```

#### 11. Paid events and their prices

```json
{ "locations": ["London"], "price": "paid", "maxItems": 500 }
```

Ticket prices, currencies, tax and every ticket type — a pricing benchmark in minutes.

#### 12. Luma's featured picks for every city

```json
{ "locations": ["everywhere"], "featuredOnly": true, "maxItems": 2000 }
```

The events Luma's editors feature on its 87 city pages: 1,476 events on 2026-10-20 (New York 79, San Francisco 53, London 51, Berlin 49 …).

#### 13. A small circle around a point

```json
{ "locations": ["40.7411,-73.9897"], "radiusKm": 3, "maxItems": 200 }
```

Events within 3 km of a point — a neighbourhood, a campus, an office.

#### 14. Online events of a calendar

```json
{ "calendars": ["https://lu.ma/ls"], "when": "all", "eventType": "online" }
```

Luma's map lists in-person events only; online events (Zoom, Meet, YouTube) come from calendars, hosts and links.

#### 15. Fastest export: list data only

```json
{ "locations": ["everywhere"], "includeDetails": false, "maxItems": 5000 }
```

Skips the per-event detail record (description, categories, ticket types): 5,000 events in 129 s.

#### 16. A map box

```json
{ "locations": ["51.28,-0.51,51.69,0.33"], "categories": ["tech"], "maxItems": 500 }
```

"south, west, north, east" in decimal degrees — here Greater London.

#### 17. A keyword in a region

```json
{ "searchTerms": ["founders"], "locations": ["California"], "maxItems": 500 }
```

California's boundary from OpenStreetMap, searched cell by cell.

#### 18. The whole Luma map

```json
{ "locations": ["everywhere"], "maxItems": 0 }
```

Every upcoming in-person event on Luma: 20,319 events, 0 duplicates, 22 minutes. Set *Maximum cost per run* high enough (see [What you pay](#what-you-pay)).

***

### Tutorial: your first run in the Apify Console

1. Open the Actor and click **Try for free** (or **Start** if it is already in your list).
2. In **Locations**, type a city — `San Francisco`, `London`, `Berlin`, `Singapore` — or a region, a country, or `everywhere`.
3. Optional: pick **Categories** (AI, Tech, Crypto, Arts & Culture …), add **Search terms**, or paste **Calendars**, **Hosts** or **Luma links**.
4. Optional filters: **Starting on or after / before** for a date window, **In person or online**, **Price**.
5. Set **Max events** (50 to try, 1,000 by default, 0 = no limit).
6. Click **Start**. The first rows appear within a few seconds in the **Output** tab; the views *Overview*, *Organisers & socials*, *Location* and *Tickets & registration* show the most useful columns.
7. Click **Export** for CSV, Excel, JSON, XML or HTML. Hosts are a list per event; in CSV they become columns `hosts/0/name`, `hosts/0/linkedin`, `hosts/1/name` …

***

### Tutorial: run it through the API

Replace `<TOKEN>` with your Apify API token (Console → Settings → Integrations).

```bash
## start a run and wait for it to finish (up to 300 s), then print the events as JSON
curl -s -X POST "https://api.apify.com/v2/acts/logiover~luma-scraper/run-sync-get-dataset-items?token=<TOKEN>&timeout=300" \
  -H "Content-Type: application/json" \
  -d '{"locations": ["San Francisco"], "categories": ["ai"], "maxItems": 200}'

## long runs: start asynchronously, poll the run, then download the dataset as CSV
curl -s -X POST "https://api.apify.com/v2/acts/logiover~luma-scraper/runs?token=<TOKEN>" \
  -H "Content-Type: application/json" -d '{"locations": ["everywhere"], "maxItems": 0}'
curl -s "https://api.apify.com/v2/actor-runs/<RUN_ID>?token=<TOKEN>"
curl -s "https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=csv&token=<TOKEN>" > luma-events.csv
```

**Node.js** (`npm i apify-client`):

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('logiover/luma-scraper').call({
    calendars: ['https://lu.ma/ls'], when: 'all', maxItems: 0,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const e of items) console.log(e.startAtLocal, e.name, e.hostNames);
```

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient
client = ApifyClient("<TOKEN>")
run = client.actor("logiover/luma-scraper").call(run_input={
    "searchTerms": ["hackathon"], "locations": ["London", "Berlin"], "maxItems": 500,
})
for e in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(e["startAtLocal"], e["name"], e["city"], [h.get("linkedin") for h in e["hosts"]])
```

***

### Input reference

| Field | Type | Default | What it does |
|---|---|---|---|
| `locations` | list of text | — | Places to read Luma's map for: one of Luma's 87 cities ("San Francisco", "NYC", "London", "Bengaluru" …), any other city, region or country (boundary from OpenStreetMap: "Bavaria", "Germany", "Brazil"), `"lat,lng"` (a circle), `"south,west,north,east"` (a box), or `"everywhere"`. |
| `radiusKm` | integer 1–500 | 50 | Circle around a city or point. Regions and countries always use their boundary. |
| `categories` | list | — | Luma's categories: `ai`, `tech`, `crypto`, `arts`, `climate`, `fitness`, `wellness`, `food`, `books`, `games`, `running`, `family`. Alone they cover the whole map; with locations, only those places. |
| `searchTerms` | list of text | — | Keywords for Luma's search, in every location (or everywhere). |
| `calendars` | list of text | — | Calendar links (`https://luma.com/ls`, `lu.ma/genai-sf`), slugs (`ls`) or ids (`cal-…`). |
| `hosts` | list of text | — | Profile links (`https://luma.com/user/lmsys`), usernames or ids (`usr-…`). |
| `urls` | list of text | — | Any luma.com / lu.ma link — events, calendars, city pages, category pages, profiles — or event ids (`evt-…`). Recognised automatically. |
| `when` | `upcoming` / `past` / `all` | `upcoming` | For calendars and hosts. The map (locations, categories, search) is upcoming only. |
| `startDate` | date | — | Only events starting on or after this day (events already running on it are kept). |
| `endDate` | date | — | Only events starting on or before this day. |
| `eventType` | `all` / `in-person` / `online` | `all` | In-person or online events only. |
| `price` | `all` / `free` / `paid` | `all` | Free or paid events only. |
| `featuredOnly` | boolean | `false` | Only the events Luma features on its city pages (with a Luma city or `everywhere`). |
| `maxItems` | integer | 1000 | Stop after this many unique events (0 = no limit). |
| `includeDetails` | boolean | `true` | Description, categories, ticket types, questions, refund policy, featured places. Off = faster list data only. |
| `includeHostProfiles` | boolean | `false` | Adds `eventsHosted`, `eventsAttended`, `joinedAt` to every host (one request per unique host). |
| `includeExternalEvents` | boolean | `true` | Keep events a calendar lists from other websites (`platform: "external"`; name, time, place and link only). |
| `proxyConfiguration` | proxy | Apify Proxy | Fallback only — the direct connection is used first. |

Sources combine: `locations` × `categories` × `searchTerms` define map searches; `calendars`, `hosts` and `urls` are added on top. Every event is saved once.

***

### Output data dictionary

Fill rates measured on 3,000 events from Luma's whole map (build 1.0.9, 2026-10-20, run `77nY6dROZmy0oOJdx`); calendar-only fields from calendar runs. Empty values are `null` (or `[]` for lists) — never `0`, never invented.

| Field | Type | Meaning | Filled | Example |
|---|---|---|---|---|
| `id` | text | Luma event id (`evt-…`; `calev-…` for external calendar items) | 100 % | `evt-kEEwMQEK7LOx4Xj` |
| `url` | text | Public event page (external items: their own site) | 100 % | `https://luma.com/zbp6a1e1` |
| `name` | text | Event title | 100 % | `SGLang Meetup with LinkedIn and LMCache` |
| `startAt` / `endAt` | ISO date | Start and end in UTC | 100 % | `2026-10-21T00:00:00.000Z` |
| `timezone` | text | IANA time zone of the event | 100 % | `America/Los_Angeles` |
| `startAtLocal` / `endAtLocal` | text | Local wall time with UTC offset | 100 % | `2026-10-20T17:00:00-07:00` |
| `durationMinutes` | number | End minus start | 100 % | `240` |
| `timeStatus` | text | `upcoming`, `ongoing`, `ended` at scrape time | 100 % | `upcoming` |
| `locationType` | text | `offline` or the online platform (`zoom`, `meet`, `youtube`, `twitch`, `discord`, …) | 100 % | `offline` |
| `isOnline` | boolean | Online event | 100 % | `false` |
| `venueName` | text | Place name as Luma shows it (not for hidden addresses) | 78.2 % | `LinkedIn Corporation - Building 950 (LSNR)` |
| `address` | text | Full postal address | 78.2 % | `…, 950 W Maude Ave, Sunnyvale, CA 94085, USA` |
| `shortAddress` | text | Street and city | 77.3 % | `950 W Maude Ave, Sunnyvale` |
| `locationNote` | text | Organiser's note on the location | 17.6 % | `Take the lift. Go to level 4!` |
| `neighborhood` | text | Neighbourhood / district | 69.4 % | `Sunnyvale West` |
| `city` | text | City | 99.0 % | `Sunnyvale` |
| `region` | text | State / region | 97.5 % | `California` |
| `country` / `countryCode` | text | Country and ISO code | 100 % / 99.6 % | `United States` / `US` |
| `latitude` / `longitude` | number | Coordinates (approximate for hidden addresses) | 100 % | `37.39245` / `-122.0412877` |
| `coordinatesApproximate` | boolean | Luma's approximate pin (hidden address) | 100 % | `false` |
| `addressHidden` | boolean | Address shown to registered/approved guests only | 100 % | `false` |
| `googlePlaceId` | text | Google place id of the venue | 78.2 % | `ChIJGVicMwC3j4AREcC64ZSIxbg` |
| `coverImageUrl` | text | Cover image | 100 % | `https://images.lumacdn.com/uploads/…png` |
| `description` | text | Full description as clean text | 98.0 % | `Join SGLang, LinkedIn and LMCache …` |
| `descriptionLinks` | list | Links in the description | 36.7 % | `["https://github.com/sgl-project/sglang"]` |
| `sponsorMentions` | list | Description lines naming sponsors / partners | 10.8 % | `["Food and drinks sponsored by our friends at Sentry."]` |
| `categories` | list | Luma categories | 76.2 % | `["AI"]` |
| `tags` | list | The calendar's own tags (calendar runs) | calendars only | `["Meetup"]` |
| `featuredIn` | list | Luma city pages / calendars featuring the event | 14.2 % | `["San Francisco"]` |
| `isFree` | boolean | Free event | 100 % | `true` |
| `price` | number | Luma's summary price, tax included (0 = free) | 99.3 % | `20` |
| `minPrice` | number | Minimum of a pay-what-you-want price | 1.4 % | `5` |
| `maxPrice` | number | Highest ticket price | 4.6 % | `56` |
| `currency` | text | ISO currency of paid events | 14.9 % | `GBP` |
| `priceIsFlexible` | boolean | Pay-what-you-want price | 13.9 % | `true` |
| `taxName` / `taxPercent` | text / number | Tax added at checkout | 2.2 % | `VAT` / `20` |
| `ticketTypes` | list | Every ticket type (see below) | 100 % | |
| `registrationStatus` | text | `open`, `waitlist`, `sold-out`, `closed`, `coming-soon` | 100 % | `waitlist` |
| `requiresApproval` | boolean | Host approves guests | 100 % | `true` |
| `isSoldOut` | boolean | No spots left | 100 % | `true` |
| `spotsRemaining` | number | Spots left (events with a limit) | 61.4 % | `0` |
| `capacity` | number | Tickets taken + spots left (events with a limit) | 61.4 % | `277` |
| `isNearCapacity` | boolean | Luma shows "almost full" | 100 % | `false` |
| `waitlistActive` | boolean | Waitlist open | 100 % | `true` |
| `guestCount` | number | "N Going" on the page | 100 % | `277` |
| `guestListShown` | boolean | Organiser shows the guest list | 100 % | `true` |
| `registrationQuestions` | list | Questions asked at registration | 55.0 % | `["What company/school do you work for?"]` |
| `refundPolicy` | text | Refund terms | 6.5 % | `Tickets are nonrefundable and nontransferable` |
| `calendarId` | text | Calendar id | 100 % | `cal-E1vs3T6MHVV1wRQ` |
| `calendarName` | text | Calendar (organiser) | 100 % | `SGLang Meetups and Events` |
| `calendarUrl` | text | Calendar page (a person's profile for personal calendars) | 100 % | `https://luma.com/SGLang` |
| `calendarDescription` | text | Calendar's short description | 44.9 % | `SGLang is an open-source …` |
| `calendarWebsite` | text | Calendar website | 39.1 % | `https://sglang.io/` |
| `calendarTwitter` | text | X (Twitter) profile | 11.9 % | `https://x.com/latentspacepod` |
| `calendarLinkedin` | text | LinkedIn page | 31.0 % | `https://linkedin.com/company/latentspacepod` |
| `calendarInstagram` | text | Instagram profile | 31.7 % | `https://instagram.com/latentspacepod` |
| `calendarYoutube` | text | YouTube channel | 13.1 % | `https://youtube.com/@…` |
| `calendarTiktok` | text | TikTok profile | 7.3 % | `https://tiktok.com/@…` |
| `calendarAvatarUrl` | text | Calendar logo | 100 % | |
| `calendarCity` / `calendarCountryCode` | text | Calendar's home city / country | 33.4 % | `San Francisco` / `US` |
| `calendarIsPersonal` | boolean | A person's own calendar | 100 % | `false` |
| `hostCount` | number | Number of hosts shown | 100 % | `3` |
| `hostNames` | text | Host names, `\|`-separated | 97.8 % | `LMSYS Org \| Qing Lan \| …` |
| `hosts` | list | Hosts (see below) | 97.9 % | |
| `featuredGuestCount` | number | Attendees Luma shows on the public event page | 100 % ‡ | `10` |
| `featuredGuestNames` | text | Their names, `\|`-separated | 52 % ‡ | `Priyanka Mary Mammen \| Ryan Lagasse \| …` |
| `featuredGuests` | list | Each one's id, name, profile link, bio, avatar, website, X/Twitter, LinkedIn, Instagram, YouTube, TikTok (same shape as `hosts`) | 52 % ‡ | |
| `platform` | text | `luma` or `external` | 100 % | `luma` |
| `source` | text | Which input found the event | 100 % | `location San Francisco (Luma city, 50 km)` |
| `detailsIncluded` | boolean | Event detail record was read | 100 % | `true` |
| `scrapedAt` | ISO date | When the row was collected | 100 % | `2026-10-20T13:17:28.734Z` |

‡ San Francisco, 120 events, 2026-10-20: 52 % of events show featured guests — 619 people, 87 % of them with at least one social profile (525 with LinkedIn).

**`hosts[]`** (fill rates per host entry, 3,000-event run; on the 20,319-event run, per unique host: LinkedIn 51.0 %, Instagram 30.9 %, website 26.9 %, X 14.3 %, YouTube 8.1 %, TikTok 5.5 %, bio 36.1 %):

| Field | Meaning | Filled |
|---|---|---|
| `id` | Luma user id (`usr-…`) | 100 % |
| `name` | Name as shown | 99.0 % |
| `username` | Luma username | 41.0 % |
| `url` | Luma profile | 100 % |
| `bio` | Short bio | 36.4 % |
| `avatarUrl` | Profile photo | 100 % |
| `website` | Website | 31.9 % |
| `twitter` / `linkedin` / `instagram` / `youtube` / `tiktok` | Profile URLs | 16.0 / 55.9 / 32.8 / 8.9 / 5.0 % |
| `isVerified` | Luma-verified | 100 % (rarely `true`) |
| `eventsHosted` / `eventsAttended` / `joinedAt` | With *Add host profile numbers* | 100 % when on |

**`ticketTypes[]`**: `id`, `name`, `type` (`free`, `fiat-price` …), `price` (before tax), `currency`, `minPrice` (pay what you want), `isFlexible`, `capacity` (12.7 % set one), `registered`, `spotsRemaining`, `requiresApproval`, `isHidden`, `isSoldOutOrClosed`, `salesStart` / `salesEnd` (3.5 % / 4.5 %), `description` (13.1 %).

***

### Output example

A real row from a run on 2026-10-20 (`includeHostProfiles` on), unedited:

```json
{
  "id": "evt-kEEwMQEK7LOx4Xj",
  "url": "https://luma.com/zbp6a1e1",
  "name": "SGLang Meetup with LinkedIn and LMCache",
  "startAt": "2026-10-21T00:00:00.000Z",
  "endAt": "2026-10-21T04:00:00.000Z",
  "timezone": "America/Los_Angeles",
  "startAtLocal": "2026-10-20T17:00:00-07:00",
  "endAtLocal": "2026-10-20T21:00:00-07:00",
  "durationMinutes": 240,
  "timeStatus": "upcoming",
  "locationType": "offline",
  "isOnline": false,
  "venueName": "LinkedIn Corporation - Building 950 (LSNR)",
  "address": "LinkedIn Corporation - Building 950 (LSNR), 950 W Maude Ave, Sunnyvale, CA 94085, USA",
  "shortAddress": "950 W Maude Ave, Sunnyvale",
  "locationNote": null,
  "neighborhood": "Sunnyvale West",
  "city": "Sunnyvale",
  "region": "California",
  "country": "United States",
  "countryCode": "US",
  "latitude": 37.39245,
  "longitude": -122.0412877,
  "coordinatesApproximate": false,
  "addressHidden": false,
  "googlePlaceId": "ChIJGVicMwC3j4AREcC64ZSIxbg",
  "coverImageUrl": "https://images.lumacdn.com/uploads/au/18f17544-0b09-4057-ac41-9bf61bc159a6.png",
  "description": "Join SGLang, LinkedIn and LMCache for an AI Infra Meetup during Open Source AI Week!\nAfter a busy day at the conference, come unwind with fellow engineers, researchers, and AI practitioners. We're bringing together the people building and deploying real-world LLM serving systems for focused technical talks, great food and drinks, and plenty of time to connect with the community. Whether you're in town for PyTorch Conf or part of the Bay Area AI ecosystem, we'd love to have you join us.\nSchedule\n• 5:00 PM: Doors open, drinks, and networking\n• 6:00 PM – 8:00 PM: Technical talks from SGLang and LinkedIn (short break around 7:00 PM)\n• 8:00 PM – 9:00 PM: Networking, food, and drinks\nTalks include\n• LinkedIn: Generative Retrieval and running SGLang in production at scale\n• SGLang: Current status and RoadMap for Q4\n• Miles: RL Training update and Feature sharing\n• LMCache: Agent and KVCache Memory management\nAdditional Information\n• Space is limited to 150 attendees. Registration required for building access.\n• Photography and videography may take place during the event for promotional purposes.\n• Part of Open Source AI Week.\nSee you at our Meetup! 🎉",
  "descriptionLinks": ["https://github.com/sgl-project/sglang", "https://www.linkedin.com/", "https://lmcache.ai/en/", "https://luma.com/opensourceaiweek"],
  "sponsorMentions": [],
  "categories": ["AI"],
  "tags": [],
  "featuredIn": ["San Francisco"],
  "isFree": true,
  "price": 0,
  "minPrice": null,
  "maxPrice": null,
  "currency": null,
  "priceIsFlexible": null,
  "taxName": null,
  "taxPercent": null,
  "ticketTypes": [
    { "id": "ttype-bJpM7F9zzcz5mtJ", "name": "Standard", "type": "free", "price": 0, "currency": null, "minPrice": null, "isFlexible": false, "capacity": null, "registered": 277, "spotsRemaining": null, "requiresApproval": true, "isHidden": false, "isSoldOutOrClosed": false, "salesStart": null, "salesEnd": null, "description": null }
  ],
  "registrationStatus": "waitlist",
  "requiresApproval": true,
  "isSoldOut": true,
  "spotsRemaining": 0,
  "capacity": 277,
  "isNearCapacity": false,
  "waitlistActive": true,
  "guestCount": 277,
  "guestListShown": true,
  "registrationQuestions": ["What company/school do you work for?"],
  "refundPolicy": null,
  "calendarId": "cal-E1vs3T6MHVV1wRQ",
  "calendarName": "SGLang Meetups and Events",
  "calendarUrl": "https://luma.com/SGLang",
  "calendarDescription": "SGLang is an open-source high-performance inference framework for LLM, built and maintained by the LMSYS Org. Join our events to learn more! All past & upcoming events: https://www.sglang.io/events",
  "calendarWebsite": "https://sglang.io/",
  "calendarTwitter": null,
  "calendarLinkedin": null,
  "calendarInstagram": null,
  "calendarYoutube": null,
  "calendarTiktok": null,
  "calendarAvatarUrl": "https://images.lumacdn.com/calendars/i4/d76dcaca-250b-4a10-8b3f-398d67ae7d41.jpg",
  "calendarCity": "San Francisco",
  "calendarCountryCode": "US",
  "calendarIsPersonal": false,
  "hostCount": 3,
  "hostNames": "LMSYS Org | Qing Lan | Sundara Raman Ramachandran",
  "hosts": [
    { "id": "usr-vdm1UDfhrYPoJi1", "name": "LMSYS Org", "username": "lmsys", "url": "https://luma.com/user/lmsys", "bio": "LMSYS Org is a non-profit research organization dedicated to incubating open-source projects and advancing research on large AI models.", "avatarUrl": "https://images.lumacdn.com/avatars/bl/bd9dc8c9-0c8e-452b-ae58-dbcf2fd4dad6.jpg", "website": "https://lmsys.org/", "twitter": "https://x.com/lmsysorg", "linkedin": "https://linkedin.com/in/xxxx", "instagram": null, "youtube": "https://youtube.com/@lmsys-org", "tiktok": null, "isVerified": false, "eventsHosted": 29, "eventsAttended": 2, "joinedAt": "2026-02-27T07:07:15.137Z" },
    { "id": "usr-oJGIf94FFmYcHpE", "name": "Qing Lan", "username": "lanking", "url": "https://luma.com/user/lanking", "bio": "MLSys @ LinkedIn", "avatarUrl": "https://images.lumacdn.com/uploads/a4/9bc1709b-bd9c-4099-becd-c6c699c2c636.jpg", "website": null, "twitter": null, "linkedin": "https://linkedin.com/in/lanking", "instagram": null, "youtube": null, "tiktok": null, "isVerified": false, "eventsHosted": 2, "eventsAttended": 12, "joinedAt": "2024-11-06T01:21:58.358Z" },
    { "id": "usr-Gcm7OTGrbEsLjVQ", "name": "Sundara Raman Ramachandran", "username": "sundar24295", "url": "https://luma.com/user/sundar24295", "bio": "LLM Inference/Recommendation Systems @ LinkedIn | Staff Engineer | SGlang Contributor | UT Austin", "avatarUrl": "https://images.lumacdn.com/avatars/ty/60a0ea91-dfad-421e-b664-386c1d156765.jpg", "website": null, "twitter": null, "linkedin": "https://linkedin.com/in/sundara-raman-ramachandran", "instagram": null, "youtube": null, "tiktok": null, "isVerified": false, "eventsHosted": 2, "eventsAttended": 12, "joinedAt": "2024-07-30T15:31:35.221Z" }
  ],
  "platform": "luma",
  "source": "event link",
  "detailsIncluded": true,
  "scrapedAt": "2026-10-20T13:17:28.734Z"
}
```

Featured guests on a real San Francisco event (platform run, 2026-10-20):

```json
"featuredGuests": [
  {
    "id": "usr-40SQEluKs96Lt2k",
    "name": "Priyanka Mary Mammen",
    "username": null,
    "url": "https://luma.com/user/usr-40SQEluKs96Lt2k",
    "bio": null,
    "avatarUrl": "https://cdn.lu.ma/avatars-default/avatar_2.png",
    "website": null,
    "twitter": "https://x.com/priyanka_mary",
    "linkedin": "https://linkedin.com/in/priyanka-mary-mammen",
    "instagram": null,
    "youtube": null,
    "tiktok": null,
    "isVerified": false
  },
  {
    "id": "usr-bw2t5tfbTPPJRRu",
    "name": "Ryan Lagasse",
    "username": null,
    "url": "https://luma.com/user/usr-bw2t5tfbTPPJRRu",
    "bio": null,
    "avatarUrl": "https://images.lumacdn.com/uploads/1l/51a52b16-0f7c-46d2-a2f2-c5ff1462a206.jpg",
    "website": null,
    "twitter": null,
    "linkedin": "https://linkedin.com/in/lagasse-ryan",
    "instagram": null,
    "youtube": null,
    "tiktok": null,
    "isVerified": false
  }
]
```

Values are exactly what Luma holds: `linkedin.com/in/xxxx` above is what LMSYS Org entered on its profile.

**CSV / Excel columns**: every field above becomes a column; lists are flattened by the export (`categories/0`, `ticketTypes/0/name`, `ticketTypes/0/price`, `hosts/0/name`, `hosts/0/linkedin`, `hosts/1/name` …). For one row per host, download JSON and expand `hosts`.

***

### Scale, speed and coverage

Measured on the Apify platform on 2026-10-20 with the default 1 GB memory:

| Input | Events | Time |
|---|---|---|
| Prefill: New York, 50 events | 50 | 3.0 s (first rows after ~1 s) |
| San Francisco, 1,000, full details | 1,000 | 49.1 s |
| London, 1,000, full details | 1,000 | 49.7 s |
| Everywhere, the 3,000 soonest, full details | 3,000 | 237 s |
| Everywhere, 5,000, list data only | 5,000 | 129 s |
| **Everywhere, everything, full details** | **20,319** | **1,339 s (22 min), 0 duplicates** |
| 17 cookbook recipes, 3–150 events each | — | 2–18 s each |

The whole-map run made 20,756 requests, every one answered (436 map pages and 20,319 event records), with no refusal and no rate-limit answer.

**Where Luma's events are** (whole map, 2026-10-20): United States 7,666 · United Kingdom 1,504 · Germany 1,289 · Canada 1,006 · Mexico 685 · Spain 570 · France 472 · Netherlands 448 · Japan 416 · India 410 · Australia 309 · Italy 294 · Switzerland 288 · Singapore 281 · Brazil 270 — 133 countries in all. Busiest cities: London 1,015 · New York 971 · San Francisco 695 · Berlin 521 · Mexico City 381 · Toronto 343 · Amsterdam 320 · Paris 296 · Brooklyn 283 · Munich 278 · Singapore 278 · Seattle 274 · Barcelona 252 · Austin 223 · Los Angeles 207.

**What the events are**: Tech 4,160 · AI 3,864 · Arts & Culture 3,426 · Fitness 1,543 · Wellness 963 · Climate 912 · Books 736 · Family 681 · Running 528 · Games 511 · Crypto 510 · Food & Drink 510 (an event can have several categories; 24.1 % have none). 79.2 % are free; paid events are priced in USD (2,008), EUR (886), GBP (423), CAD (359), JPY (118), AUD (94), CHF (73) and 29 more currencies. 13,290 different calendars and 25,440 different hosts published them; 83.0 % of events carry at least one website or social profile of the calendar or a host.

**Accuracy.** On 2026-10-20, 17 deliberately different events (paid in GBP with VAT, EUR, JPY, Mexico, India, Australia, a hidden address with approval, a 106-person waitlist, a pay-what-you-want ticket, two with registration closed, an online Zoom event, events with sponsors and with many host profiles) and 12 random events from the whole-map run were compared field by field with the live luma.com pages — the event's schema.org data and visible text (venue, address, map link, ticket list, organiser text, description links, sponsor lines), each host's profile page and the calendar page: **796 of 799 values matched**; the 3 others were "N Going" counts that had changed by one between scraping and checking (Luma's own API confirmed the new numbers).

***

### What you pay

Pay per event saved — no subscription, no extra charge for compute or proxies. The price per 1,000 events falls with your Apify plan:

| Apify plan | Price per 1,000 events |
|---|---|
| Free | $2.50 |
| Bronze | $2.23 |
| Silver | $1.97 |
| Gold, Platinum, Diamond | $1.70 |

Examples:

- **1,000 events** (one city, full details): $2.50 on the free plan, $1.70 on Gold and above.
- **10,000 events**: $25.00 … $17.00.
- **The whole Luma map** (≈ 20,000 upcoming events): ≈ $50 … $34.
- **100,000 events** (weekly whole-map exports for five weeks): $250 … $170.

Only saved events are charged: duplicates found by several of your sources, events outside your area and events removed by your filters cost nothing. Host profile numbers and event details are included.

**Maximum cost per run.** Every run has a cost limit (set it under *Run options → Maximum cost per run*, or `maxTotalChargeUsd` in the API). Luma Scraper stops cleanly when the limit is reached, keeps everything collected so far and says so in the status message — a test run on 2026-10-20 with a $0.05 limit ended with *"Saved 22 events — this run's maximum cost ($0.05) covers 22 results at the current price. Raise "Maximum cost per run" to get more."* (22 rows, 22 charged). For a whole-map export, allow about $55.

***

### Integrations

#### API (curl)

See the [API tutorial](#tutorial-run-it-through-the-api): `run-sync-get-dataset-items` returns the events in one call for runs under five minutes; longer runs are started asynchronously and their dataset downloaded as JSON, CSV, XLSX, XML or HTML.

#### Node.js and Python

The official `apify-client` packages start runs, wait for them and iterate the dataset (examples above). Upsert by `id` to keep your own table current.

#### Make, Zapier and n8n

Use the Apify app (Make, Zapier) or the Apify node (n8n): *Run an Actor* with your input, then *Get dataset items*. Typical flows: new AI events in your city → Slack channel; events with `sponsorMentions` → a sponsorship pipeline; hosts → CRM.

#### Google Sheets and Airtable

Append rows with the Apify → Google Sheets integration or a Make/Zapier step (`=IMPORTDATA()` on the CSV link works for small lists); in Airtable use `id` as the primary key and update records on every run.

#### CRM via webhooks (HubSpot, Salesforce, Pipedrive, Attio)

A webhook on *Run succeeded* lets your endpoint read the dataset and upsert companies (calendars) and contacts (hosts) by their Luma ids.

#### Scheduling

Schedules in the Apify Console run the Actor every day or week with the same input — e.g. `locations: ["London"]`, `startDate` today, `endDate` in 7 days. Because rows carry stable ids, de-duplicate across runs on your side.

#### MCP and AI agents

The Actor runs through Apify's MCP server, so AI assistants and agents (Claude, ChatGPT, Cursor and others that speak MCP) can call it with a plain-language request ("find AI hackathons in Berlin next month") and read the rows.

#### Data warehouses and BI

Export to S3, BigQuery, Snowflake or Postgres with the Apify integrations or a small script; UTC times, country codes, categories and prices are dashboard-ready.

***

### Performance tips

- **Need only names, dates, places and organisers?** Turn off *Include full event details*: the whole map without details takes minutes instead of 22.
- **Big exports:** set *Max events* to 0 and a sufficient *Maximum cost per run*; one run for "everywhere" is faster than many runs for single cities (it reads Luma's whole-map list once).
- **Cities:** Luma's city names (San Francisco, New York, London …) use Luma's own city coordinates — no geocoding, fastest start. Use `radiusKm` to tighten or widen the circle.
- **Countries:** a country name filters by Luma's own country code, so border towns and islands are right.
- **Calendars with long histories:** use `when: "past"` and a `startDate` to stop at a year instead of reading everything.
- **Host profile numbers** cost one request per unique host; leave them off unless you rank hosts.
- **Keyword search** is semantic; for exact topics, combine a category with a few search terms.

***

### Troubleshooting

**"Saved N events (max results reached) in X s."** — The run stopped at *Max events*. Raise it (0 = no limit) for more.

**"Saved N events (every matching event read) in X s."** — Everything that matched your input was read.

**"Saved N events (stopped at the run time limit) in X s."** — The run used its time limit (default 3,600 s). Raise the timeout in *Run options*, turn off details, or split the input.

**"… N event detail(s) could not be read; those rows carry the list data only."** — A few event records did not answer in time; those rows have `detailsIncluded: false` (no description, categories or ticket types). If many rows are affected the run is marked PARTIAL in its SUMMARY.

**"… N page(s) could not be read."** — Some map or calendar pages failed repeatedly; the SUMMARY shows `outcome: PARTIAL` and `pagesSkipped`. Re-run the same input to fill the gaps.

**"No events matched on Luma — the search ran fine but returned 0 events."** — Luma has no matching event. Common reasons follow in the same message: a place with no Luma events, a date window in the past for the map, `eventType: "online"` with locations (the map lists in-person events only), or a calendar without upcoming events (use `when: "all"`).

**"Saved N events — this run's maximum cost ($X) covers N results at the current price. Raise "Maximum cost per run" to get more."** — The cost limit stopped the run cleanly; `SUMMARY.stoppedBy` is `MAX_COST`.

**"Saved 0 events — this run's maximum cost ($X) does not cover a single result at the current price."** — Raise *Maximum cost per run*.

**Run failed: "Nothing to scrape: give locations …"** — The input has no locations, categories, search terms, calendars, hosts or links.

**Run failed: "No events collected: no page could be fetched (…)"** — Luma could not be reached at all (outcome `BLOCKED` or `FETCH_FAILED`). This is an access failure, not an empty result; try again later or set a residential proxy in *Proxy configuration*.

**Run failed: "No events collected and N page(s) could not be read, so an empty result cannot be confirmed."** — Pages failed and nothing was saved; re-run.

**Warnings in the log:**

- *"Could not find the place "X"…"* — add a country ("Springfield, Illinois") or use coordinates.
- *"Unknown category "X"…"* — use one of the 12 category names.
- *"Calendar "X" not found on Luma"*, *"… is a Luma event, not a calendar"*, *"Luma profile "X" not found"*, *"Not a Luma link"*, *"Luma has no page at …"*, *"Unsupported Luma page"* — check the link.
- *"Luma's map … lists in-person events only …"* — online events come from calendars, hosts and links.
- *"X lies outside the part of the map where Luma lists events (60° S – 80° N)."*
- *"Featured events only needs one of Luma's own cities …"* — `featuredOnly` works with Luma's 87 cities or "everywhere".
- *"Luma asked this connection to slow down … using the Apify datacenter proxy"* / *"Luma rate-limited this connection …"* — normal on shared platform addresses; the run continues through the proxy.
- *"Luma did not answer the whole-map request as expected; reading the map cell by cell instead"* — automatic fallback, slower but complete.

***

### Limits

- **The map is upcoming, in-person events only.** Luma's map does not list past events (it refuses requests for them) or online events. Past and online events come from calendars, hosts and links.
- **Featured guests, not full guest lists.** Luma's public event page shows a handful of attendees ("featured guests", usually up to ~10) with their public profiles — those are exported in `featuredGuests`. The complete guest list is visible only to signed-in guests and is not exported; `guestCount` gives the full "N Going".
- **Hidden addresses stay hidden.** When the organiser shows the address only to approved guests, you get the neighbourhood, city, region, country and Luma's approximate pin.
- **Search is Luma's semantic search.** Results include related events; Luma answers 50 per area, so very broad terms in very busy areas are read through smaller areas while results stay on topic.
- **Sponsors** have no field on Luma; `sponsorMentions` are the description's own lines about sponsors and partners.
- **Profiles are what people typed.** A host's LinkedIn can be a placeholder (`/in/xxxx`) or out of date; stray spaces in handles are removed.
- **Prices:** `price` and `maxPrice` are Luma's summary prices with tax included; ticket-type prices are before tax (`taxName`, `taxPercent`). Prices are in the event's currency (yen and won have no decimals).
- **`capacity`** is tickets taken plus spots left, available only when the organiser set a limit.
- **Speed is paced to Luma's limits** (about 15 event records per second), so the whole map with details takes about 22 minutes.
- **Snapshots.** Events change; schedule runs for fresh data.

***

### Compared with the other ways to get Luma data

| | Luma Scraper | Luma's own exports and API | Copying from the website |
|---|---|---|---|
| Events from any organiser | Yes | Only calendars you manage | Yes, by hand |
| Whole city / country / world in one run | Yes | No | No |
| Past events of a calendar | Yes | Your own calendars | Scrolling |
| Host and organiser socials | Yes, as URLs | Your own guests | Clicking each profile |
| Ticket types, prices, approval, waitlist | Yes | Your own events | Partly visible |
| Output | CSV, Excel, JSON, API, integrations | CSV for your own data | Manual |
| Needs a Luma account / subscription | No | Yes (API needs a paid Luma plan) | No |

***

### FAQ

#### What is Luma Scraper?

An Apify Actor that exports events from Luma (luma.com, lu.ma) — by city, country, category, keyword, calendar, host or link — as structured rows with dates, places, prices, registration data and the organisers' and hosts' public profiles.

#### Is there an official Luma API?

Luma's API covers only the calendars you manage (on a paid Luma plan). Luma Scraper reads the public event data any visitor sees, from every organiser.

#### How do I scrape Luma events into Excel or CSV?

Run the Actor with your locations or calendars, open the Output tab and click Export → CSV or Excel. Through the API, download `…/datasets/<id>/items?format=csv` or `format=xlsx`.

#### Can I export all events from Luma?

All upcoming in-person events on Luma's map: `{"locations": ["everywhere"], "maxItems": 0}` — 20,319 events on 2026-10-20 in 22 minutes. Past and online events come from calendars and hosts.

#### How do I get all events in San Francisco (or New York, London, Berlin) from Luma?

`{"locations": ["San Francisco"]}` — a 50 km circle around the city like luma.com's own city search. 1,000 events take about 50 seconds.

#### How do I scrape a Luma calendar?

Paste its link into **Calendars**: `{"calendars": ["https://lu.ma/ls"], "when": "all"}` returns its upcoming and past events.

#### Can I get past events from Luma?

Yes, for calendars and hosts (`when: "past"` or `"all"`). Luma's map itself lists only upcoming events.

#### How do I find AI events (or tech, crypto, wellness …) on Luma?

Use **Categories**: `{"categories": ["ai"], "locations": ["London"]}`, or everywhere. Luma's 12 categories: AI, Tech, Crypto, Arts & Culture, Climate, Fitness, Wellness, Food & Drink, Books, Games, Running, Family.

#### Can I search Luma events by keyword?

Yes — **Search terms** use Luma's own search in every location ("hackathon", "founders", "yoga", "web3").

#### Does it get the hosts' LinkedIn, X (Twitter) and Instagram?

Yes, for every host who entered them on Luma: `hosts[].linkedin`, `.twitter`, `.instagram`, `.youtube`, `.tiktok`, `.website`. On the whole map, 55.6 % of events had at least one host with LinkedIn.

#### Does it get the organiser's website and social links?

Yes: `calendarWebsite`, `calendarLinkedin`, `calendarTwitter`, `calendarInstagram`, `calendarYoutube`, `calendarTiktok`.

#### Can I get attendee lists or guest emails?

You get the attendees Luma shows publicly on each event page — `featuredGuests`, with each person's name, bio, website and social profiles (X/Twitter, LinkedIn, Instagram, YouTube, TikTok). In San Francisco on 2026-10-20, 52 % of events showed featured guests (619 people across 120 events, 525 with a LinkedIn profile). The full guest list and e-mail addresses are visible only to signed-in guests and are not exported; `guestCount` gives the total.

#### Do I need a Luma account or login?

No. Everything comes from public pages; no login, cookies or browser.

#### How fast is it?

First rows in about a second; 1,000 events with full details in about 50 seconds; the whole Luma map in about 22 minutes.

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

$2.50 per 1,000 events on the free plan, down to $1.70 on Gold and above. The whole map is about $34–50.

#### Why do some events have no address?

The organiser chose to show the address only to registered or approved guests. Those rows have `addressHidden: true`, the city and Luma's approximate coordinates.

#### Why do some events have no hosts?

The organiser shows only the calendar ("Presented by …") — 2 % of events. The calendar's own name, website and socials are still there.

#### Are the times in local time?

Both: `startAt`/`endAt` in UTC and `startAtLocal`/`endAtLocal` in the event's time zone (`timezone`).

#### Does it include online events?

Yes, from calendars, hosts and links (`isOnline`, `locationType` such as `zoom`). Luma's map has in-person events only.

#### Can I filter by date?

Yes — `startDate` and `endDate` (YYYY-MM-DD).

#### Can I get only free events, or only paid ones?

`"price": "free"` or `"price": "paid"`.

#### How do I get ticket prices?

`price`, `minPrice`, `maxPrice`, `currency` and the full `ticketTypes` list with each ticket's price, capacity and sales window.

#### What does "registrationStatus: closed" mean?

The event page says "Registration Closed": the organiser stopped registrations or all ticket sales windows ended.

#### How are duplicates handled?

Each event is saved once per run by its Luma event id, whichever source finds it first; `source` tells you which.

#### Can I get the events Luma features on its city pages?

`"featuredOnly": true` with a Luma city — or "everywhere" for all 87 cities (1,476 events on 2026-10-20).

#### Can I monitor new Luma events every day?

Schedule the Actor daily with a date window and upsert rows by `id`.

#### Why does a keyword search return events without the word in the title?

Luma's search is semantic ("buildathon" for "hackathon") and also reads descriptions; deeper zoom levels keep only events that mention the term.

#### What are sponsorMentions?

Lines of the description that mention sponsors or partners ("sponsored by …", a "Sponsors" heading and the names under it). Luma has no sponsor field; this is the organiser's own text.

#### Can an AI agent use this Actor?

Yes, through Apify's MCP server or the API; the rows are typed JSON with clean text descriptions.

#### Why did my run stop before Max events?

Everything matching was read, the cost limit was reached (`MAX_COST` in the SUMMARY) or the time limit came first — the status message says which.

#### I need a field or a filter that is missing. Can you add it?

Yes — write to us through the Issues tab; we reply within 24 hours.

***

### Glossary

- **Event** — one Luma event page (`evt-…`).
- **Calendar** — the page a community, company or person publishes events on ("Presented by …" on the event page).
- **Host** — a person or organisation listed under "Hosted By".
- **Luma city** — one of Luma's 87 city pages (luma.com/sf, /london, /berlin …).
- **Category** — Luma's topic pages (AI, Tech, Crypto …).
- **Featured** — an event chosen for a Luma city page or a community calendar.
- **Approval required** — the host approves each registration.
- **Waitlist** — registrations beyond capacity wait for a spot.
- **Ticket type** — a kind of ticket with its own price, capacity and sales window.
- **Pay what you want** — a flexible price with a minimum (`priceIsFlexible`, `minPrice`).
- **Hidden address** — shown only to registered/approved guests (`addressHidden`).
- **Map cell** — a box of at most 10 × 10 degrees that Luma's map answers exactly.
- **External event** — an event a calendar lists from another website.
- **Maximum cost per run** — the spending cap of a pay-per-event run.
- **Dataset** — the run's table of results on Apify.

***

### Legal and data protection

Luma Scraper reads information that Luma publishes on public pages for anyone to see, without logging in and without bypassing any access control; it does not export full guest lists, e-mail addresses or phone numbers. Event pages include personal data of hosts and of the featured guests Luma displays (names, profile photos, bios and the social profiles they chose to publish). If you process this data you are the controller: under the GDPR, UK GDPR, CCPA and similar laws, have a lawful basis (for example legitimate interest for B2B outreach), tell people where you got their data, honour objections and deletion requests, and keep only what you need. Respect Luma's terms of use and do not use the data for spam. The Actor paces its requests to Luma's published limits. This is not legal advice.

***

### Changelog

#### 1.0 (2026-10-20)

- First release: locations (Luma cities, any city/region/country, coordinates, boxes, everywhere), categories, keyword search, calendars (upcoming and past), hosts, any luma.com/lu.ma link, Luma's featured picks.
- Event details (description, categories, ticket types, questions, refund policy, featured places), optional host profile numbers.
- Whole map in 22 minutes (20,319 events, 0 duplicates); 1,000 events in about 50 seconds.
- Registration status as the event page shows it; prices in the correct units for zero- and three-decimal currencies; tax shown separately.
- Clean outcomes (COMPLETED / PARTIAL / EMPTY_RESULT succeed with a message; BLOCKED / FETCH_FAILED fail) and a SUMMARY record; clean stop at the maximum cost per run.

***

### Support

Questions, a missing field, a site change? Open an issue on the Actor's **Issues** tab — we reply within 24 hours. Tell us the run id and what you expected; we usually ship fixes within days.

> Luma Scraper is an independent tool, not affiliated with, endorsed by or sponsored by Luma AI, Inc. All trademarks belong to their owners.

# Changelog

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

# Actor input Schema

## `locations` (type: `array`):

Every upcoming in-person event Luma lists in these places. Use one of Luma's cities ("San Francisco", "New York", "London", "Berlin", "Singapore" … — the circle set in "Radius" around the city), any other city, region or country ("Austin", "Bavaria", "Germany", "Brazil" — the boundary from OpenStreetMap), "latitude, longitude" (a circle) or "south, west, north, east" (a box). "everywhere" reads Luma's whole map. Combine with categories or search terms to narrow down.

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

Size of the circle around a city or a "latitude, longitude" point. 50 km is the radius luma.com itself searches around a city (San Francisco with Oakland, Palo Alto and Mountain View). Regions and countries always use their own boundary.

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

Luma's own event categories. Alone they cover the whole map (e.g. every AI event worldwide); with locations, only those places.

## `searchTerms` (type: `array`):

Keywords, as you would type them into Luma's search: "AI agents", "founders", "hackathon", "yoga", "web3". Searched in every location (or everywhere when no location is given); Luma answers 50 events per search, so the map is split until every part has been read.

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

Luma calendars — the pages communities, companies and organisers publish their events on: https://luma.com/ls, lu.ma/genai-sf, a slug like "ls" or a calendar id (cal-…). Online and in-person events; set "Upcoming or past" to include the calendar's past events.

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

Luma profiles: https://luma.com/user/lmsys, a username or a user id (usr-…). Returns the events they host.

## `urls` (type: `array`):

Any luma.com or lu.ma link — event pages (luma.com/abc123xy), calendars, Luma city pages (luma.com/sf), category pages (luma.com/ai), profiles (luma.com/user/…) — or event ids (evt-…). Each is recognised automatically.

## `when` (type: `string`):

Calendars and hosts have a history: read their upcoming events, their past events, or both. Luma's map (locations, categories, search terms) lists upcoming events only.

## `startDate` (type: `string`):

Optional. Only events that start on or after this date (events already running on that day are kept).

## `endDate` (type: `string`):

Optional. Only events that start on or before this date (e.g. the next 30 days).

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

Keep all events, in-person events only, or online events only (Zoom, Google Meet, YouTube and other streams).

## `price` (type: `string`):

Keep all events, free events only, or paid (ticketed) events only.

## `featuredOnly` (type: `boolean`):

Instead of every event around a Luma city, return only the events Luma's editors feature on that city's page (typically 5–80 per city). With "everywhere", the featured events of all of Luma's cities.

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

Stop after this many unique events across all sources. 0 = no limit (Luma's whole map holds about 20,000 upcoming in-person events). Big runs need a big enough "Maximum cost per run".

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

Reads each event's own page data: the full description (with its links and sponsor mentions), Luma categories, every ticket type with price and capacity, registration questions, refund policy and where Luma features it. Included in the price; turn off only for the fastest export of the list data.

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

For every host, adds how many events they have hosted and attended on Luma and when they joined — a quick way to rank organisers. One extra request per unique host.

## `includeExternalEvents` (type: `boolean`):

Calendars can also list events that live on other sites (a conference's own page). Those rows have name, time, place and the outside link only (platform = "external").

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

Used only as a fallback. The scraper talks to Luma over a direct connection first; when Luma asks it to slow down it continues through Apify datacenter proxies (a new address per request), or through the proxy chosen here.

## Actor input object example

```json
{
  "locations": [
    "New York"
  ],
  "radiusKm": 50,
  "categories": [],
  "searchTerms": [],
  "calendars": [],
  "hosts": [],
  "urls": [],
  "when": "upcoming",
  "eventType": "all",
  "price": "all",
  "featuredOnly": false,
  "maxItems": 50,
  "includeDetails": true,
  "includeHostProfiles": false,
  "includeExternalEvents": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All events collected in this run.

# 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 = {
    "locations": [
        "New York"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "locations": ["New York"],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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