# Luma Event Scraper - Hosts, Ticket Prices & Guest Counts (`webdata_labs/luma-event-scraper`) Actor

Scrape upcoming events from Luma (lu.ma) across 60 cities, with the host's social handles, ticket price, guest and ticket counts, venue, the community running it and the full description. No login, no API key.

- **URL**: https://apify.com/webdata\_labs/luma-event-scraper.md
- **Developed by:** [WebData Labs](https://apify.com/webdata_labs) (community)
- **Categories:** Automation, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 event scrapeds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

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

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

# README

## Luma Event Scraper - hosts, ticket prices and guest counts

Scrape upcoming events from **Luma (lu.ma)** across 60 cities and get back a clean row per event with **the host's social handles**, the ticket price, how many people are going, the venue, and the community running it.

No login. No API key. No browser. Pure HTTP, runs on 256 MB.

**$1.50 per 1,000 events. No Actor start fee.**

### ✅ What you get / ❌ what this isn't

✅ **Host social handles**: `hostTwitter`, `hostInstagram`, `hostLinkedin`. Measured on a 195-event run across San Francisco and New York: **179 of 195 events carried at least one**
✅ Ticket price in cents with currency, plus `isFree` and `isSoldOut`
✅ `guestCount` and `ticketCount`, so you can see which events have traction
✅ Venue, city, region, country, and whether the event is in person, online or hybrid
✅ The **community** behind each event (`calendarName`, `calendarUrl`), not just the event
✅ Optional full description and Luma's own category tags
✅ Monitoring mode that returns only events you have not already been given

❌ **No past events.** Luma's discover endpoint serves upcoming events only, and refuses every other time period outright
❌ Not an attendee scraper. Public event listings and their public hosts only
❌ Not a ticket-buying bot

### 🔎 Why use this Actor

An events feed on its own is a list of names and dates. What makes it worth having is **who is behind each event and how to reach them**.

Luma publishes the host's X, Instagram and LinkedIn handles on the event, and this Actor returns them as their own columns. That is the difference between "there are 40 AI events in Berlin next month" and a working list of 40 organisers you can contact, each with the size of their audience attached.

For sponsors, community teams, recruiters and developer-relations people, that is the whole job.

### 🗂️ Coverage

Luma curates its own city list, so the Actor offers exactly the 60 cities Luma actually serves:

**Americas**: San Francisco, New York, Los Angeles, Austin, Chicago, Boston, Seattle, Miami, Denver, Philadelphia, Houston, Atlanta, Dallas, Phoenix, Toronto, Vancouver, Montreal, Calgary, Mexico City, Buenos Aires

**Europe**: London, Berlin, Paris, Amsterdam, Lisbon, Barcelona, Madrid, Warsaw, Stockholm, Zurich, Helsinki, Copenhagen, Oslo, Munich, Milan, Prague, Brussels, Vienna, Dublin, Budapest, Rome, Istanbul

**Asia Pacific**: Singapore, Tokyo, Seoul, Taipei, Bangkok, Jakarta, Manila, Kuala Lumpur, Ho Chi Minh City, Bengaluru, Mumbai, Sydney, Melbourne, Auckland

**Middle East and Africa**: Dubai, Tel Aviv, Lagos, Nairobi

### 👥 Who it's for

- **Event sponsors and BD teams** building a list of organisers worth sponsoring, with audience size and contact handles attached.
- **Community and DevRel teams** tracking which communities are active in which city, and how big their events get.
- **Recruiters** who use technical meetups as a sourcing channel.
- **Market researchers** measuring where startup and AI activity is concentrating, by counting events per city over time.
- **Event aggregators** that want a clean upcoming-events feed with prices and venues.

### 📚 Example tasks

| What you want | Input |
| -- | -- |
| [Events in San Francisco](https://apify.com/webdata_labs/luma-event-scraper/examples/luma-events-in-san-francisco) | `{"cities": ["sf"]}` |
| [Events in New York](https://apify.com/webdata_labs/luma-event-scraper/examples/luma-events-in-new-york) | `{"cities": ["nyc"]}` |
| [Everything in London](https://apify.com/webdata_labs/luma-event-scraper/examples/luma-events-in-london) | `{"cities": ["london"], "maxResults": 200}` |
| [Free events in Berlin](https://apify.com/webdata_labs/luma-event-scraper/examples/luma-free-events-in-berlin) | `{"cities": ["berlin"], "onlyFreeEvents": true}` |
| [Full descriptions and categories](https://apify.com/webdata_labs/luma-event-scraper/examples/luma-events-with-full-descriptions) | `{"cities": ["sf"], "includeDescription": true}` |
| The whole US tech corridor | `{"cities": ["sf", "nyc", "austin", "seattle", "boston"], "maxResults": 500}` |
| [Europe in one run](https://apify.com/webdata_labs/luma-event-scraper/examples/luma-events-across-europe) | `{"cities": ["london", "berlin", "paris", "amsterdam", "lisbon", "barcelona"], "maxResults": 400}` |
| [Asia Pacific](https://apify.com/webdata_labs/luma-event-scraper/examples/luma-events-across-asia-pacific) | `{"cities": ["singapore", "tokyo", "seoul", "bengaluru", "sydney"], "maxResults": 400}` |
| [Only what is new since the last run](https://apify.com/webdata_labs/luma-event-scraper/examples/luma-new-events-daily-monitor) | `{"cities": ["sf", "nyc"], "onlyNewEvents": true}` |

### ⚙️ How it works

Pick your cities. Every request carries an explicit city, because Luma personalises its discover feed by visitor location and a run that leaves that to chance is not reproducible.

Each city is paged until Luma says it has no more upcoming events. Every row is pushed the moment it is parsed, so a run you stop early keeps everything it found.

### 🔁 Monitoring: only events you have not seen before

Set `onlyNewEvents` to `true` and schedule it. The Actor remembers the event ids it has **delivered** and returns only what is new, so a daily monitor never re-delivers, and never re-bills, the same event.

Run it as a saved task and keep using that task: the memory belongs to the task, not to one-off runs from the Actor page.

### 📥 Input

| Field | Type | Default | What it does |
| -- | -- | -- | -- |
| `cities` | array | `["sf", "nyc"]` | Which Luma cities to scrape, from the fixed list of 60. |
| `maxResults` | integer | `200` | Total events across all cities. |
| `onlyFreeEvents` | boolean | `false` | Keep only events with no ticket price. |
| `includeDescription` | boolean | `false` | Also fetch each event's full description and categories. Free, but one extra request per event. |
| `onlyNewEvents` | boolean | `false` | Return only events not delivered by a previous run of the same task. |

#### Accepted input aliases

`slugs`, `city` and `queries` are accepted for `cities`, and `maxItems` and `maxEvents` for `maxResults`, so input pasted from another Actor's docs runs without editing.

There is nothing to configure about proxies, concurrency, retries or pacing. Those are handled internally and included in the price.

### 📤 Output

One row per event.

```json
{
  "eventId": "evt-ILBNJlfial3ou6k",
  "name": "Spatial Intelligence + Generative 3D Hackathon",
  "eventUrl": "https://lu.ma/b101ml40",
  "startAt": "2026-09-05T17:00:00.000Z",
  "endAt": "2026-09-06T03:00:00.000Z",
  "timezone": "America/Los_Angeles",
  "locationType": "offline",
  "venue": "Founders Inc",
  "city": "San Francisco",
  "region": "California",
  "country": "United States",
  "isFree": true,
  "priceCents": null,
  "priceCurrency": null,
  "isSoldOut": true,
  "guestCount": 240,
  "ticketCount": 300,
  "registrationAvailability": "waitlist",
  "hostNames": ["Alex Carrabre", "Wayne Sutton"],
  "hostTwitter": "carrabre",
  "hostInstagram": "waynesutton",
  "hostLinkedin": "alexcarrabre",
  "calendarName": "Founders, Inc. Events",
  "calendarUrl": "https://lu.ma/fdotinc",
  "coverUrl": "https://images.lumacdn.com/uploads/wi/908a9351.png",
  "categories": ["cat-ai"],
  "descriptionText": null,
  "citySlug": "sf",
  "scrapedAt": "2026-09-05T22:59:37Z"
}
```

#### Output fields

| Field | Type | Description |
| -- | -- | -- |
| `eventId` | string | Luma's own event id. Stable, and what monitoring mode remembers. |
| `name` | string | Event title. |
| `eventUrl` | string | The public Luma page. |
| `startAt` | string | Start time, UTC. |
| `endAt` | string | End time, UTC. |
| `timezone` | string | The event's own timezone, for converting the times back. |
| `locationType` | string | `offline`, `online` or `hybrid`. |
| `venue` | string | Street address or venue name. Empty when the host reveals it only on registration. |
| `city` | string | City the event is actually in, which may be a neighbour of the city you searched. |
| `region` | string | State or region. |
| `country` | string | Country. |
| `isFree` | boolean | Whether the event is free. |
| `priceCents` | number | Ticket price in minor units. Null on free events. |
| `priceCurrency` | string | Currency of `priceCents`. |
| `isSoldOut` | boolean | Whether registration is closed for capacity. |
| `guestCount` | number | How many people are going. |
| `ticketCount` | number | How many tickets exist. |
| `registrationAvailability` | string | `open`, `waitlist` or closed. |
| `hostNames` | array | Every host's display name. |
| `hostTwitter` | string | **The first host's X handle.** |
| `hostInstagram` | string | **The first host's Instagram handle.** |
| `hostLinkedin` | string | **The first host's LinkedIn handle**, normalised from Luma's `/in/name` path. |
| `calendarName` | string | The community running the event. |
| `calendarUrl` | string | That community's Luma page, where its other events live. |
| `coverUrl` | string | Cover image. |
| `categories` | array | Luma's own tags, for example `cat-ai`. Needs `includeDescription`. |
| `descriptionText` | string | Full description as plain text. Needs `includeDescription`. |
| `citySlug` | string | Which city search produced this row. |
| `scrapedAt` | string | UTC timestamp of the row. |

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

| Events | Cost |
| -- | -- |
| 100 | $0.15 |
| 1,000 | $1.50 |
| 10,000 | $15.00 |

$0.0015 per event and nothing else. No Actor start fee, so a run that returns nothing costs nothing. Host handles, prices, guest counts and descriptions are all included at the base rate.

### ⚠️ Limits and caveats

Measured 5 September 2026, so you do not spend a run finding them out.

- **Upcoming events only.** Luma's discover endpoint rejects every time period except the future outright, so past events cannot be scraped at all. If you need historical events, this is the wrong source.
- **The catalogue is genuinely small.** New York, the largest city, carried **110 upcoming events** in total, and San Francisco 85. Most cities return 10 to 40. Scrape several cities per run; there is no depth to page into and a bigger `maxResults` will not find more.
- **Cities are a fixed list, not free text**, because Luma only serves the cities it curates. A city outside the list is skipped with a warning rather than silently returning the wrong place. Note that `bengaluru` works and `bangalore` does not.
- **A city search includes its neighbours.** Searching San Francisco returned San Jose, Oakland and Palo Alto events too. Filter on `city` afterwards if you need the city proper.
- **About half of events hide their venue.** 42 of 80 San Francisco events had an address; the rest reveal it only to registered guests, so `venue` is empty by design rather than missing.
- **Some events hide their counts.** `guestCount` and `ticketCount` come back as zero when the host has turned off the guest list, even on an event that is sold out.
- **Handles are the first host's.** Events with several hosts list them all in `hostNames`, but the social columns take the first host that has each handle, so the columns stay scalar and sortable.
- **Descriptions cost an extra request each**, which is why they are off by default.

### 🔁 Run it on the Apify platform

Schedule it, use monitoring mode, and pull results with the Apify API or the JavaScript and Python clients. The dataset exports as JSON, CSV, Excel and XML.

### 🤖 Use with AI agents via MCP

**Claude Code**

```bash
claude mcp add apify --transport http https://mcp.apify.com --header "Authorization: Bearer <YOUR_APIFY_TOKEN>"
```

**Cursor or Claude Desktop**

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }
    }
  }
}
```

Then ask in words: "find free AI events in Berlin next month on Luma and give me the organisers' X handles". The agent fills `cities` and `onlyFreeEvents` itself.

### 🔗 Use this Actor in n8n

Add the **Apify** node, choose **Run Actor**, pick `webdata_labs/luma-event-scraper` and paste your input JSON. Chain **Get Dataset Items** after it. A common pattern is a weekly schedule with `onlyNewEvents: true` feeding new events into a CRM or a Slack channel.

### ⚖️ Is it legal to scrape Luma?

This Actor reads only the public discover feed and public event pages that Luma serves to logged-out visitors. It does not log in, does not touch guest lists, and does not collect attendee data. Host social handles are the ones each host chose to publish on their own public event page.

You remain responsible for what you do with the output, including any outreach. If you contact organisers, the usual marketing and privacy rules where you operate still apply.

### 🧩 Related Actors

- [Booking.com Scraper](https://apify.com/webdata_labs/booking-scraper) - hotel prices and availability across dates.
- [Google Hotels Scraper](https://apify.com/webdata_labs/google-hotels-scraper) - the full OTA price ladder for a property, in one request.
- [Airbnb Market Intelligence](https://apify.com/webdata_labs/airbnb-market-intelligence) - short-let listings, pricing and occupancy signals for a market.
- [Contractor Leads Scraper](https://apify.com/webdata_labs/home-services-growth-leads) - HVAC, plumbing and roofing firms scored on how much room they have to grow.
- [Google Maps New Business Monitor](https://apify.com/webdata_labs/google-maps-new-lead-monitor) - only places that appeared since your last run, for a standing prospect feed.

### ❓ FAQ

#### Can I scrape past events?

No. Luma's discover endpoint accepts only upcoming events and returns an error for anything else, so no Actor can offer past events from this source.

#### Why did my run return only 30 events?

Because that city has 30 upcoming events. Luma's catalogue is small per city: New York, the biggest, holds around 110. Add more cities rather than raising `maxResults`.

#### Why is the venue empty on some events?

The host chose to reveal the address only to registered guests. About half of San Francisco events do this. The city, region and country are still there.

#### Can I search by keyword or category?

Not on this endpoint. Luma's discover feed is organised by city, and category tags only appear on the event's own page, which is why `categories` needs `includeDescription`. Filter your dataset on `categories` or `name` afterwards.

#### Which host do the social columns belong to?

The first host that has each handle. All host names are in `hostNames` if you need the full list.

#### Why is my city not in the list?

Because Luma does not curate it. The Actor offers exactly the 60 cities Luma serves; anything else is rejected by Luma itself rather than quietly returning the wrong place.

#### Are guest counts always accurate?

They are what Luma publishes. Hosts who turn off the public guest list show zero, even on a sold-out event, so treat zero as "not disclosed" rather than "nobody is going".

#### Am I charged for a run that finds nothing?

No. The only charge is per event returned, and there is no start fee.

### 📝 Changelog

**0.1** - 5 September 2026. First release. 60 cities, host social handles, ticket prices, guest counts, community pages, optional descriptions and categories, free-events filter, and monitoring mode.

### 🛠️ Support

Found a bug or need a field? Open an issue on the Actor's Issues tab. Reports with a run id get fixed fastest.

### ⭐ Rate this Actor

If it saved you time, a rating helps other people find it.

# Actor input Schema

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

Which Luma cities to scrape. Luma only publishes the cities it curates, so this is a fixed list rather than free text. Pick several: most cities carry only 10 to 40 upcoming events.

## `maxResults` (type: `integer`):

Stop after this many events across all cities. New York, the largest city, carries about 110 upcoming events, so add more cities rather than raising this.

## `onlyFreeEvents` (type: `boolean`):

Keep only events with no ticket price.

## `includeDescription` (type: `boolean`):

Also fetch each event's full description, categories and ticket types from its own page. Off by default: it adds one request per event. Free either way.

## `onlyNewEvents` (type: `boolean`):

Return only events that were not delivered by a previous run of the same saved task. Use this for scheduled monitoring so you are not billed twice for the same event.

## Actor input object example

```json
{
  "cities": [
    "sf",
    "nyc"
  ],
  "maxResults": 200,
  "onlyFreeEvents": false,
  "includeDescription": false,
  "onlyNewEvents": false
}
```

# Actor output Schema

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

One row per Luma event, with host social handles, ticket price and guest counts.

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

The same rows, trimmed to the fields most buyers scan first.

## `OUTPUT` (type: `string`):

Counts per city, and any city Luma rejected.

# 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",
        "nyc"
    ]
};

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

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

```

## MCP server setup

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