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

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

- **URL**: https://apify.com/haketa/luma-event-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Lead generation
- **Stats:** 35 total users, 21 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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 🎟️ — Scrape lu.ma Events, Hosts & Calendars

Extract **Luma ([lu.ma](https://lu.ma/)) events** as clean, structured data — without writing any code. **Discover events by city or category**, scrape entire **calendars/communities**, or pull **individual events**, and get full details including **date, location, GPS, tickets, guest counts and host/organizer social profiles**.

Fast and reliable: this scraper is built on Luma's own data layer, so it returns complete, structured JSON — no missing fields, no flaky page-rendering.

> 💡 **Two superpowers:** (1) **City/category discovery** — list every event happening in a city like SF, NYC or London. (2) **Host lead-gen** — every event ships its organizers' Instagram, X/Twitter, LinkedIn, TikTok, YouTube and website.

***

### 📋 Table of contents

- [What does it do?](#what-does-it-do)
- [Use cases](#use-cases)
- [How to use it](#how-to-use-it-step-by-step)
- [Input parameters](#input-parameters)
- [Input examples](#input-examples)
- [Output — data fields](#output--data-fields)
- [Sample output record](#sample-output-record)
- [Host & organizer lead generation](#host--organizer-lead-generation)
- [Tips & best practices](#tips--best-practices)
- [Frequently asked questions](#frequently-asked-questions)
- [Changelog](#changelog)

***

### What does it do?

Luma powers tens of thousands of tech meetups, conferences, parties, workshops and community events worldwide. This actor turns Luma into a structured dataset you can export to **JSON, CSV, Excel, XML or HTML**, or pull from the **Apify API**.

Four ways to scrape:

- 🌆 **By city** — discover all upcoming events in a city (e.g. `sf`, `nyc`, `london`).
- 🏷️ **By category** — filter to a topic like `ai`, `tech`, `arts`, `crypto`, `wellness`.
- 📅 **By calendar/community** — scrape every upcoming event from a Luma calendar (e.g. a company or community page).
- 🔗 **By URL** — paste any Luma event, calendar or city URL.

For every event you get the **name, start/end time + timezone, venue and full address with GPS coordinates (or online link), cover image, ticket info (free/paid, price, sold-out, spots remaining), guest count, the calendar it belongs to, and full host/organizer profiles with social handles.** Optionally fetch each event's **description, ticket types/prices and categories**.

***

### Use cases

**🎯 Event marketers & community builders**

- Track every event in your city or niche and benchmark turnout (guest counts).
- Find the most active organizers and communities to partner with.
- Monitor competitor and ecosystem events in real time.

**📇 Sales & lead generation**

- Build lists of **event organizers with their social profiles and websites**.
- Target hosts running events in your category/city for sponsorship or outreach.
- Feed organizer leads straight into your CRM.

**📊 Researchers & analysts**

- Analyse event trends by city, category, time and price.
- Study the events ecosystem with clean, exportable data.

**🤝 Sponsors & venues**

- Discover upcoming events that fit your audience.
- Map events geographically by coordinates.

**🤖 Data & AI teams**

- Power event-discovery apps, newsletters and dashboards.
- Build datasets of events, hosts and venues.

***

### How to use it (step by step)

No coding required.

1. Click **Try for free / Start**.
2. Pick how you want to scrape:
   - **Cities** — add city slugs like `sf`, `nyc`, `london` (from `luma.com/<slug>`).
   - **Category** — optionally narrow to `ai`, `tech`, `arts`, etc.
   - **Calendars** — add community/calendar handles (from `luma.com/<handle>`).
   - **Luma URLs** — paste event/calendar/city URLs directly.
3. Set **Max items** (start with 100).
4. Turn on **Include full event details** if you want descriptions, ticket prices and categories.
5. Click **Save & Start**, then export the results.

***

### Input parameters

| Field | Type | Description |
|------|------|-------------|
| `cities` | array | City slugs to discover events in (e.g. `sf`, `nyc`, `london`). |
| `category` | string | Optional category slug (e.g. `ai`, `tech`). Works with cities or on its own. |
| `calendars` | array | Calendar/community handles to scrape upcoming events from. |
| `startUrls` | array | Any Luma URLs — events, calendars, or cities (auto-detected). |
| `includeDetails` | boolean | Fetch each event's description, ticket types and categories. Default `false`. |
| `maxItems` | integer | Max events. `0` = no limit. Default `200`. |
| `proxyConfiguration` | object | Proxy settings. Default: Apify Proxy on. |
| `maxConcurrency` | integer | Max parallel requests. Default `5`. |

***

### Input examples

**1) Discover all events in San Francisco**

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

**2) AI events across several cities**

```json
{
  "cities": ["sf", "nyc", "london"],
  "category": "ai",
  "maxItems": 500
}
```

**3) Scrape a community calendar with full details**

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

**4) Specific events / pages by URL**

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

***

### Output — data fields

Each event is one dataset row. Core fields:

| Field | Description |
|------|-------------|
| `eventId` | Luma event ID |
| `name` | Event name |
| `url` / `slug` | Event URL and slug |
| `eventType` | Event type |
| `visibility` | public / private |
| `startAt` / `endAt` | Start and end datetime (ISO) |
| `timezone` | Event timezone |
| `locationType` | `offline` / `online` |
| `isOnline` | Boolean |
| `address` / `fullAddress` | Venue address |
| `city` / `region` / `country` | Location |
| `latitude` / `longitude` | GPS coordinates |
| `virtualUrl` | Link for online events |
| `coverUrl` / `socialImageUrl` | Images |
| `isFree` | Boolean |
| `price` / `maxPrice` | Ticket price(s) |
| `isSoldOut` | Boolean |
| `spotsRemaining` | Remaining spots |
| `requireApproval` | Whether registration needs approval |
| `registrationAvailability` | Registration state |
| `guestCount` | Number of guests |
| `ticketCount` | Number of tickets |
| `calendarName` / `calendarSlug` / `calendarUrl` | Owning calendar |
| `hosts` | Array of host profiles (see below) |
| `hostCount` | Number of hosts |
| `featuredGuestCount` | Number of featured guests |
| `scrapedAt` | ISO timestamp |

Each entry in `hosts[]`: `name`, `username`, `website`, `bio`, `avatarUrl`, `isVerified`, `instagram`, `twitter`, `linkedin`, `tiktok`, `youtube`.

With **`includeDetails: true`** you also get:

| Field | Description |
|------|-------------|
| `description` | Full event description (plain text) |
| `ticketTypes` | Array of `{ name, price, currency, maxCapacity, isHidden }` |
| `categories` | Array of `{ slug, name }` |

***

### Sample output record

```json
{
  "eventId": "evt-8DRVhINH9LTM7T4",
  "name": "Where Design Begins: An Open Exhibition",
  "url": "https://luma.com/nqkyxczb",
  "slug": "nqkyxczb",
  "startAt": "2026-06-04T18:00:00.000Z",
  "endAt": "2026-06-11T21:00:00.000Z",
  "timezone": "America/Los_Angeles",
  "locationType": "offline",
  "isOnline": false,
  "fullAddress": "488 Bryant St, San Francisco, CA 94107, USA",
  "city": "San Francisco",
  "region": "California",
  "country": "United States",
  "latitude": 37.7817006,
  "longitude": -122.3956533,
  "coverUrl": "https://images.lumacdn.com/...",
  "isFree": true,
  "isSoldOut": false,
  "requireApproval": false,
  "guestCount": 142,
  "calendarName": "Vizcom",
  "calendarUrl": "https://luma.com/vizcom",
  "hosts": [
    {
      "name": "Vizcom",
      "username": "vizcom",
      "website": "https://vizcom.com/",
      "bio": "From Sketch to 3D in seconds.",
      "isVerified": true,
      "instagram": "vizcom",
      "twitter": "vizcomtech",
      "linkedin": "vizcom"
    }
  ],
  "hostCount": 1,
  "scrapedAt": "2026-06-04T12:00:00.000Z"
}
```

***

### Host & organizer lead generation

Every event includes its **organizers' contact and social footprint** — name, username, website, bio, and handles for **Instagram, X/Twitter, LinkedIn, TikTok and YouTube**. Combine this with **city/category discovery** to build targeted lists like *"every AI-event organizer in NYC, with their socials"* — ideal for partnerships, sponsorships and outreach.

***

### Tips & best practices

- 🌆 **Use city slugs from the URL bar** — open `luma.com`, go to a city, and copy the slug (e.g. `sf`, `los-angeles`).
- 🏷️ **Combine city + category** to focus on exactly the events you care about.
- 🧪 **Start with `maxItems: 50`** to confirm your inputs.
- ⚡ **Leave `includeDetails` off** for fast, cheap discovery; turn it on when you need descriptions, ticket prices and categories.
- 💾 **Use the Apify API / integrations** to push results into Google Sheets, a database, or a webhook, and **schedule** runs to track new events.

***

### Frequently asked questions

**Can I get every event in a city?**
Yes — add the city slug to **Cities** and the actor paginates through all upcoming events.

**Can I filter by topic?**
Yes — set **Category** (e.g. `ai`, `tech`, `arts`) alone or together with cities.

**Do I get organizer contact info?**
Yes — each event includes its hosts with website, bio and social handles.

**Can I scrape a single event or a community calendar?**
Yes — paste the URL into **Luma URLs**, or add a calendar handle to **Calendars**.

**Do I get ticket prices and descriptions?**
Turn on **Include full event details** to add descriptions, ticket types/prices and categories.

**What export formats are supported?**
JSON, CSV, Excel, XML, HTML table, RSS — plus the Apify API and integrations.

***

### Changelog

**Last updated:** 2026-07-02 — Actor verified and maintained. Data pipeline tested for quality, structure and freshness; selectors/endpoints confirmed against the live site.

**0.1.0**

- Initial release: discover events by city and category, scrape calendars/communities, and scrape individual events by URL.
- Cursor pagination, optional full-detail enrichment (description, ticket types, categories).
- Complete host/organizer profiles with social handles for lead generation.

# Actor input Schema

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Proxy settings for the run. The default works well.

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

Maximum parallel requests.

## Actor input object example

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

# Actor output Schema

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

All events collected during the run.

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

Open this run in the Apify Console.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "cities": [
        "sf"
    ],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "cities": ["sf"],
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

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

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

```

## CLI example

```bash
echo '{
  "cities": [
    "sf"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/luma-event-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=haketa/luma-event-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/YaDCczmWopeg9pAy9/builds/KhddpoGa8XsNvDBMt/openapi.json