# Luma Event Scraper: Hosts, Tickets, New Events (`automation_craft/luma-event-scraper`) Actor

Scrape public Luma (lu.ma) events by city, category, keyword, calendar, host or link: dates, venue and coordinates, ticket prices, sold out and approval flags, guest counts, hosts with LinkedIn and X links. Monitor new events and guest count changes. Export to JSON, CSV or Excel.

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

## Pricing

from $1.50 / 1,000 events

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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: Hosts, Tickets, New Events

**Scrape Luma events** (lu.ma, now luma.com) into clean rows: dates in UTC and local time, venue with address and
coordinates, ticket prices, sold out, waitlist and approval flags, guest counts, the hosts with their LinkedIn, X and
Instagram links, the calendar, and with full details the description, categories, ticket types and registration
questions. Find events by city, by any point on the map, by category, by keyword, by community calendar, by host, or
paste event links. Run it on a schedule with a monitor name and each run delivers only the events that are new, plus a
change report when a known event's guest count grows, it sells out, or its start time moves.

No Luma account, no cookies, no API key. Reads only the public event data Luma's own pages show to every visitor.

#### Who uses it

- **Sales and investor prospecting**: the hosts of tech, AI and crypto events with their LinkedIn and X links, and the
  public featured guests of each event (optional).
- **Event newsletters, directories and calendars**: every public event near a city, walked to the end, with dates, venue,
  price and a cover image.
- **Sponsorship and community teams**: which events in a city or category draw the most guests, how fast they fill, which
  sell out.
- **Agents and automations**: a structured Luma feed through the Apify API, with a monitor so a schedule only ever sends
  what is new.

### Quick start

1. Pick a city in **Cities** (for example `sf`, `nyc`, `london`), or paste Luma links in **Luma links**.
2. Optional: add **Categories**, **Keywords** or the **Filters** (dates, minimum guests, free or paid, sold out, approval,
   in person or online, countries).
3. Set **Maximum events** and click **Start**. Download the rows as JSON, CSV or Excel, or read them through the API.
4. To watch for new events, give the run a **Monitor name** and schedule it. Turn on **Report changes** to also get a row
   when a known event's guest count, sold out state or start time moves.

### What you get

One row per event (`type: "event"`). Fill rates measured on 9,887 distinct public events read on 2026-10-11 (4,415
outside the US, 1,213 past events) and, for the full details, on 294 events (`FEASIBILITY.md`):

| Field | What it holds | Filled |
|---|---|---|
| `eventId`, `url`, `name` | Luma's event id, the event page, the title | 100% |
| `startAt`, `endAt`, `timezone`, `startLocal`, `endLocal`, `durationMinutes` | start and end in UTC and in the event's own time zone | 100% |
| `format`, `locationType` | `in_person`, `online` or `unknown`, and Luma's own location type | 100% |
| `city`, `region`, `country`, `countryCode` | where the event takes place | 98.1% city, 98.5% country |
| `latitude`, `longitude` | coordinates of the venue | 98.5% |
| `venueName`, `address`, `googlePlaceId`, `addressVisibility` | the venue and full address when the host shows it (`guests_only` when Luma shows it to registered guests only) | 75.1% address |
| `isFree`, `price`, `maxPrice`, `currency` | free or paid, the lowest and highest ticket price | price on 20.7% (the paid events) |
| `isSoldOut`, `spotsRemaining`, `isNearCapacity`, `requiresApproval`, `waitlistEnabled`, `waitlistActive`, `registrationStatus` | availability as Luma shows it | 100% (spots remaining 60%) |
| `guestCount`, `guestListShown` | registered guests as the event page shows them; `null` when the host hides the guest list, never a false 0 | 59.5% shown and above 0 |
| `hosts`, `hostNames`, `hostLinkedinUrls`, `hostCount` | every host with name, Luma profile, bio, LinkedIn, X, Instagram, TikTok, YouTube and website links | 98.4% (LinkedIn on 7,624 of 13,213 hosts) |
| `calendar` | the community calendar: name, link, description, website and social links | 100% |
| `featuredGuestCount`, `featuredGuests` | the up to 10 attendees Luma shows on the page, with their links (only with **Featured guests** on) | 59.5% |
| `description`, `descriptionLinks` | the description as plain text and the links in it (full details) | 96.9% |
| `categories` | Luma's categories of the event (full details) | 84.7% |
| `ticketTypes` | every ticket type: name, kind, price, currency, capacity, spots left, approval, sale dates (full details) | 100% |
| `registrationQuestions` | the questions the host asks at registration (full details) | 59.5% |
| `featuredIn`, `refundPolicy`, `language` | where Luma features the event, the refund policy, the page language (full details) | 37.4%, 5.8%, 99.7% |
| `coverImageUrl`, `visibility`, `platform`, `source`, `monitorChange`, `scrapedAt` | the cover image, Luma's visibility, `luma` (or `external` for a calendar entry from another site), which input found the row, `new` in a monitor run, the time of the read | 100% |

Other rows: `eventUpdate` (a monitor's change report: `changes`, `guestCountBefore`, `guestCountNow`, `guestCountChange`,
`soldOutBefore`, `soldOutNow`, `startAtBefore`, `lastDeliveredOn`), `host` (a host profile: bio, `eventsHosted`,
`eventsAttended`, `joinedAt`, links, `foundOnEvents`), `status` (a free row for a link Luma does not know, an empty
search, a failed page or a stop) and one `summary` row at the end with the run's counters.

Example event row (shortened; a real row of run T1KWQ3hmPzsSYjZkX on 2026-10-11):

```json
{
  "type": "event",
  "eventId": "evt-CPrQbJ5hNcrLCDT",
  "url": "https://luma.com/greptile-3hiu",
  "name": "Greptile x Datadog Happy Hour",
  "startAt": "2026-10-13T22:00:00.000Z",
  "startLocal": "2026-10-13T18:00",
  "timezone": "America/New_York",
  "format": "in_person",
  "venueName": "The New York Times",
  "address": "The New York Times, 620 8th Ave, New York, NY 10018, USA",
  "city": "New York",
  "countryCode": "US",
  "latitude": 40.756268899999995,
  "longitude": -73.990337,
  "categories": ["AI"],
  "isFree": true,
  "isSoldOut": false,
  "requiresApproval": true,
  "guestCount": 220,
  "guestListShown": true,
  "hostNames": "Greptile, Datadog",
  "hostLinkedinUrls": "https://www.linkedin.com/company/greptile, https://www.linkedin.com/company/datadog",
  "detailsIncluded": true
}
```

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

Pay per event, with Apify's Store discounts by plan:

| Event | Free plan | Bronze | Silver | Gold |
|---|---|---|---|---|
| Event (one event row) | $0.002 | $0.0019 | $0.0017 | $0.0015 |
| Event update (a monitor's change report) | $0.002 | $0.0019 | $0.0017 | $0.0015 |
| Host profile (only with Host profiles on) | $0.002 | $0.0019 | $0.0017 | $0.0015 |
| Results page (only in monitor runs: one list page read, up to 50 events, 100 on a calendar, or one link read) | $0.0002 | $0.0002 | $0.0002 | $0.0002 |
| Actor start (once per run, and once more if you resurrect it) | $0.004 | $0.004 | $0.004 | $0.004 |

Platinum and Diamond plans pay the Gold price. The Store pricing card shows these prices per 1,000 events: "$2.00 / 1,000"
on the Event row means one event costs 0.2 cents. Full event details, featured guests and the filters cost nothing extra.

Examples on the Free plan: 100 events near a city cost $0.004 + 100 x $0.002 = $0.204. 1,000 events cost $2.004. A daily
monitor of a city whose feed holds 300 events (6 list pages) and finds 12 new ones costs $0.004 + 6 x $0.0002 + 12 x $0.002
\= $0.0292 that day.

Free (a run still pays its start fee, and a monitor run its Results pages): links Luma does not know, events that fail your filters, empty searches, invalid input, repeated events, status rows
and the summary. A monitor never charges an event twice.

Work that delivers nothing is bounded: a run may work 30 seconds plus 3 seconds per paid row (and 2 seconds per Results
page) before it stops with a status row that says so. A search whose filters almost no event passes, or a long list of
links Luma does not know, ends there; narrow the search or split the list. A monitor's own list pages and link reads are
paid as Results pages and never count against it.

### Input

| Field | What it does |
|---|---|
| `cities` | Luma cities (`sf`, `nyc`, `london`, ... 87 in the list). By default every public event near the city, all categories, from now on. |
| `coordinates` | Any other place as `"latitude,longitude"`, for example `"30.2672,-97.7431"`. Luma answers with the events around it (measured up to about 70 km). |
| `categories` | Luma categories: `ai`, `arts`, `books`, `climate`, `crypto`, `family`, `fitness`, `food`, `games`, `running`, `tech`, `wellness`. With cities or points: that category near each. Alone: that category on every continent. |
| `keywords` | Words or phrases an event's name or description must hold (whole words; the description counts when the event is read in full). With other sources they filter; alone each keyword is one Luma search (at most 50 events per keyword). |
| `cityFeed` | `nearby` (every event near the city, the default) or `featured` (only the events on Luma's own city page). |
| `urls` | Luma event, calendar, host (`luma.com/user/<name>`), city or category links, or ids `evt-`, `cal-`, `usr-`. |
| `period` | For calendar and host links: `upcoming` (default), `past` or `all`. |
| `startDateFrom`, `startDateTo`, `startWithinDays` | A window on the event's own local start date. |
| `minGuests`, `price`, `availability`, `approval`, `format`, `countries` | Minimum guests (hidden guest lists never pass), free or paid, open or sold out, host approval, in person or online, ISO country codes or names. |
| `maxItems` | The most event rows one run delivers (100 when left empty). |
| `includeDetails` | Full details (description, categories, ticket types, questions). On by default; off skips the full read for searches, calendars and hosts (faster, the same price); an event link is always read in full. |
| `includeFeaturedGuests`, `includeHostProfiles`, `includeExternalEvents` | Featured guests on event rows; one host profile row per host; calendar entries hosted on other sites. Off by default. |
| `monitorName`, `reportChanges`, `minGuestChange` | The monitor: only new events, and change reports when guest counts move by at least `minGuestChange`. |
| `stopAfterMisses` | A run stops after this many links in a row that Luma does not know (200 by default). |

Input example:

```json
{
  "cities": ["sf", "nyc"],
  "categories": ["ai"],
  "startWithinDays": 14,
  "minGuests": 50,
  "availability": "open",
  "maxItems": 500,
  "monitorName": "ai-events-sf-nyc",
  "reportChanges": true
}
```

### The monitor: new events and guest count changes

Give the run a **Monitor name** and schedule it (daily or hourly). The monitor remembers every event it delivered under
that name and never delivers or charges it again. Each run walks its sources to the end or to its row cap (a feed sorted by date can gain a
new event on any page) and pays one Results page per list page read and per link read (a list of event links is re-read
every run, to find new ones and changes). With **Report changes** on, a known event whose guest
count moved by at least **Minimum guest count change**, whose guest count the host showed or hid, that sold out or
reopened, or whose start time moved, comes back as one `eventUpdate` row with the figures before and now. One monitor name
belongs to one set of settings; a name is per listing. A memory holds up to 100,000 events.

### FAQ

#### How do I get every Luma event in my city?

Put the city in **Cities** and leave **City feed** on `nearby`: the run reads every public event Luma lists around the city
to the end of the feed (1,162 events near San Francisco on 2026-10-11). `featured` gives only the shorter list on Luma's
own city page.

#### Can I get Luma event data without Luma Plus or an API key?

Yes. Luma's official API needs a Luma Plus plan and only reaches your own calendars. This Actor reads the public event
pages any visitor sees, with no account and no key.

#### Can I scrape a Luma event's guest list?

No. Luma shows the full guest list only to signed in users, and this Actor does not sign in. It delivers the guest count
when the host shows it and, on request, the up to 10 featured guests Luma shows on the public page.

#### How do I export Luma events to CSV or Google Sheets?

Run the Actor, then download the dataset as CSV or Excel, or connect the Google Sheets integration on the run. Flat
columns such as `hostNames` and `hostLinkedinUrls` sit next to the full `hosts` objects for spreadsheets.

#### Can I filter by date, country or guest count?

Yes: a start date window, countries, minimum guests, free or paid, sold out or open, host approval, in person or online.
Events that fail a filter are left out and not charged.

#### Why does this Actor run with limited permissions?

It needs nothing beyond its own storage: the run's dataset, and for a monitor a named key-value store it creates itself.
Limited permissions keep it from reading any other data in your account.

### What this Actor does not do

- No full guest lists: they are behind Luma's login (Luma answers "You are not signed in.").
- No organizer e-mail addresses guessed from other websites; it delivers the links Luma shows.
- No separate calendar lead rows; each event row carries its calendar with its links.
- No other platforms (Eventbrite, Meetup) in the same run, and no ICS file or webhook of its own (use the platform's
  integrations).
- A keyword alone searches Luma's own search, which answers at most 50 events per keyword; add a city, a point or a
  category to go deeper.
- Hidden addresses stay hidden: an event that shows its address to guests only gives its city, area and coordinates.
- A host who asked Luma to keep their profile away from search engines gets no host profile row.

### API

```bash
curl -X POST "https://api.apify.com/v2/acts/automation_craft~luma-event-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"cities":["london"],"categories":["tech"],"maxItems":50}'
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation_craft/luma-event-scraper').call({ cities: ['nyc'], minGuests: 100, maxItems: 200 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

```python
from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("automation_craft/luma-event-scraper").call(run_input={"urls": ["https://luma.com/user/Betaworks"], "period": "past"})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

### Changelog

- 0.1 (2026-10-11): first release.

### More data tools by Automation Craft

- [LinkedIn Company Employees Scraper - No Login](https://apify.com/automation_craft/linkedin-company-employees-scraper)
- [LinkedIn Company Scraper - Details, No Login](https://apify.com/automation_craft/linkedin-company-scraper)
- [SEC Form D Scraper: Offerings & Funding Leads](https://apify.com/automation_craft/sec-form-d-scraper)
- [US New Business Registrations Scraper - LLC Leads](https://apify.com/automation_craft/us-new-business-registrations-scraper)
- [Threads Profile Scraper: Followers, Bio, Posts](https://apify.com/automation_craft/threads-profile-scraper)
- [Substack Scraper: Posts, Notes and Profiles](https://apify.com/automation_craft/substack-scraper)

# Changelog

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

# Actor input Schema

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

Luma cities (87 in the list, slug or name, for example sf, nyc, london). By default every public event near the city, in all categories, upcoming or under way (see "City feed"). Combine with categories to read only those categories near each city.

## `coordinates` (type: `array`):

Any other place as "latitude,longitude" in decimal degrees, for example "30.2672,-97.7431" for Austin. Luma answers with the events around the point (measured up to about 70 km away).

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

Luma categories. With cities or points: that category near each of them. Alone: the category over every continent, one walk per continent.

## `keywords` (type: `array`):

Words or phrases. An event is kept when its name or description holds one of them as a whole word (case does not matter; the description counts when the event is read in full: event links always, other sources with full details on). With cities, points, categories or links they filter those events. Alone, each keyword is one Luma search, which answers at most 50 events per keyword.

## `cityFeed` (type: `string`):

nearby: every public event near the city, walked to the end. featured: only the events on Luma's own city page (a shorter list Luma picks; no category choice).

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

Links such as https://luma.com/<event>, https://lu.ma/<calendar>, https://luma.com/user/<name>, luma.com/sf or luma.com/ai, or ids evt-..., cal-..., usr-.... An event link gives that event; a calendar or host link gives its events (see "Calendar and host events"). A link Luma does not know is a free status row.

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

Which events a calendar or host link gives: upcoming (default), past or all.

## `startDateFrom` (type: `string`):

YYYY-MM-DD. Compared with the event's own local start date.

## `startDateTo` (type: `string`):

YYYY-MM-DD. Compared with the event's own local start date. A walk sorted by date ends at the first page past this date.

## `startWithinDays` (type: `integer`):

Events starting from the run's day (UTC) up to this many days later; 0 is today only. Instead of the two dates above.

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

Only events whose host shows the guest count and at least this many guests are registered. Events with a hidden guest list never pass.

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

Free or paid events, as Luma marks them.

## `availability` (type: `string`):

Sold out or still open, as Luma marks them.

## `approval` (type: `string`):

Events where the host approves every registration, or where anyone can register.

## `format` (type: `string`):

In person or online. Events whose location Luma does not give pass only "Any".

## `countries` (type: `array`):

Two letter codes (US, GB, DE) or English names. Events without a country (online events) never pass.

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

The most event rows (new events and change reports) one run delivers. 100 when left empty.

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

Read every delivered event in full: description, categories, every ticket type, registration questions, where Luma features it. On when left empty. Off: searches, calendars and hosts skip the full read (faster, the same price, those fields stay empty there); an event link is always read in full.

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

Add the up to 10 attendees Luma shows on the event page (name and their public links). Off when left empty. Same price.

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

Add one row per host of the delivered events: bio, events hosted and attended, join date and links (the Host profile event, once per host per run). Off when left empty. A person who asked Luma to keep their profile away from search engines gets no row.

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

Calendars can list events hosted on other websites. On: they are delivered as rows (name, start, place, link) and charged as events. Off when left empty.

## `monitorName` (type: `string`):

A name of your choice (letters, digits, spaces, . \_ , - : # ( )). The monitor remembers every event it delivered and never delivers or charges it again as a new event. In a monitor run every list page and every link read is one Results page event. One name belongs to one set of settings; a name is per listing.

## `reportChanges` (type: `boolean`):

With a monitor: deliver a change report (the Event update event) when a known event's guest count moved, the host showed or hid it, it sold out or reopened, or its start time moved. Off when left empty.

## `minGuestChange` (type: `integer`):

With "Report changes": a guest count change is reported when it moved by at least this many guests. 1 when left empty.

## `stopAfterMisses` (type: `integer`):

A run stops after this many links in a row that Luma does not know (200 when left empty); 20,000 switches it off.

## Actor input object example

```json
{
  "cities": [
    "sf"
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `items` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "cities": [
        "sf"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation_craft/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": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation_craft/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": 10
}' |
apify call automation_craft/luma-event-scraper --silent --output-dataset

```

## MCP server setup

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