# Luma Events Scraper – lu.ma Events & Organizer Leads (`extractlyspace/luma-events-scraper`) Actor

Get public Luma (lu.ma) events by city and topic, calendar or URL. Returns name, dates, venue, coordinates, price, sold-out status and guest count, plus each organizer's public profile, website and social links. Built for event discovery and organizer lead lists. No login needed.

- **URL**: https://apify.com/extractlyspace/luma-events-scraper.md
- **Developed by:** [Spase Nikolov](https://apify.com/extractlyspace) (community)
- **Categories:** Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## 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.

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 Events Scraper – lu.ma Events & Organizer Leads

This Actor returns public events from Luma (lu.ma) for the cities (optionally narrowed to a topic), calendars or event links you give it. Each row has the event name, start and end time, venue, address and coordinates when Luma shows them publicly, price, sold-out status and guest count. With organizer details switched on, each row also carries the organizer's name, Luma page, website, public X, LinkedIn and Instagram links, and the host names. No Luma login is needed.

### Use this to

- **Discover events** in a city, optionally on one topic, such as AI events in London next month.
- **Build a lead list of event organizers** with their websites and social links.
- **Monitor a calendar for new events** by scheduling a run with `onlyNew` turned on.
- **Research sponsorship and partnership targets** by seeing who runs events in your field and how large they are.

### Sample output

| recordType | name | startAt | city | priceMin | guestCount | organizerName | organizerWebsite |
|---|---|---|---|---|---|---|---|
| event | Founders and Builders Meetup | 2026-12-04T18:30:00.000Z | San Francisco | 0 | 142 | Bay Builders | https://example.com |

Every event row has the same 26 fields, including `eventId`, `url`, `timezone`, `venueName`, `address`, `latitude`, `longitude`, `isOnline`, `category`, `isFree`, `priceCurrency`, `soldOut`, `organizerUrl`, `organizerTwitter`, `organizerLinkedin`, `organizerInstagram` and `hostNames`. A value Luma does not publish is returned as `null`. The organizer fields are `null` when organizer details are off or Luma publishes none. `hostNames` is an empty list (never `null`) when there are no hosts or organizer details are off.

### Pricing

You pay per event:

- `event`: $0.0015 for each event returned.
- `organizer-details`: $0.003 for each event that has organizer data, only when organizer details are on.

Examples: 20 events with organizer details cost at most $0.09. 100 events without organizer details cost $0.15.

Explanatory rows (see below) are never charged. The run stops when it reaches your spending limit.

### Input

- **cities**: accepts city names or Luma city slugs, such as `san-francisco` or `london`. Returns upcoming events in and around each city.
- **categories**: optional topics that narrow the cities, so you get topic events in and around each city: family, books, games, tech, food, ai, running, arts, climate, fitness, wellness, crypto. It needs `cities`; without them the run returns an `invalid_input` row.
- **calendarUrls**: links to Luma calendar or community pages, such as `https://lu.ma/ls`. Their events are returned as they are, whatever `categories` says.
- **eventUrls**: links to single Luma events, such as `https://lu.ma/abc123xy`. Returned as they are, whatever `categories` says.
- **dateFrom / dateTo**: the first and last day to include, written `YYYY-MM-DD`, inclusive. A `dateFrom` after `dateTo`, or a date not in `YYYY-MM-DD` form, returns an `invalid_input` row.
- **maxEvents**: the most events to return in total, 1 to 500 (default 20). Each returned event is charged.
- **includeOrganizerDetails**: adds organizer name, Luma page, website, social links and host names (default on).
- **onlyNew**: returns only events not returned by earlier runs with the same sources (default off).

Send at least one of `cities`, `calendarUrls` or `eventUrls`. `categories` only works together with `cities`.

### What you get when nothing matches

When nothing matches or the input needs correcting, the run succeeds and returns a short explanatory row instead of an empty result. If Luma cannot be reached and nothing could be returned, the run fails with a clear message. If only some sources could be reached, you get their events plus a `partial` row for each source that could not. The explanatory row has `recordType: "status"`, a `message` in plain language and a `subject` naming what it refers to. The `status` is one of:

- `no_results`: nothing matched the input, or nothing new appeared since the last run.
- `invalid_input`: the input could not be used, for example no source or a malformed date.
- `not_found`: a city, category or link was not found on Luma.
- `partial`: a source could not be reached or was only partly scanned.
- `limit_reached`: the run stopped at your spending limit.

### What it never returns

Guest lists, attendee data, email addresses, phone numbers, and addresses that Luma shows only to registered guests.

### FAQ

**How are dates compared?** By UTC day. An event late in the evening local time can fall on the next UTC day.

**Do I need a Luma account?** No. The Actor reads only public information.

**How does `onlyNew` remember events?** The Actor stores the IDs of events it has returned in a key-value store named `luma-events-scraper-seen` in your own Apify account, separately for each combination of sources. A later run with the same sources skips them. Changing the sources starts a fresh list.

This Actor reports usage statistics to its developer to keep it reliable: the Actor's name and build number, the time of the run, the run's outcome, row counts, events charged, an estimate of the revenue from those events, an estimate of what paid data sources cost for the run (always zero for this Actor), duration, a short error category when a run fails, partly fails or meets upstream data in an unexpected shape, how the run was started, whether the account is on a paid plan, and a one-way hash of the Apify user ID. It never reports your inputs or the data returned.

# Actor input Schema

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

City names or Luma city slugs, for example san-francisco or london. Returns upcoming events in and around each city. Send at least one of cities, calendarUrls or eventUrls.

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

Optional topics that narrow the cities: only events on these topics in and around each city are returned. Needs cities. Values: family, books, games, tech, food, ai, running, arts, climate, fitness, wellness, crypto. Example: \["ai"].

## `calendarUrls` (type: `array`):

Links to Luma calendar or community pages, for example https://lu.ma/ls. All their upcoming events are returned.

## `eventUrls` (type: `array`):

Links to single Luma events, for example https://lu.ma/abc123xy. Use this to fetch specific events you already know.

## `dateFrom` (type: `string`):

Earliest event day, YYYY-MM-DD, inclusive, compared by UTC day (a late local evening can fall on the next UTC day). dateFrom must not be after dateTo. Example: 2026-12-01.

## `dateTo` (type: `string`):

Latest event day, YYYY-MM-DD, inclusive, compared by UTC day (a late local evening can fall on the next UTC day). dateFrom must not be after dateTo. Example: 2026-12-31.

## `maxEvents` (type: `integer`):

The most events to return in total, from 1 to 500. Each returned event is charged.

## `includeOrganizerDetails` (type: `boolean`):

Adds the organizer's name, Luma page, website, public social links and host names. Charged as an add-on only for events that have organizer data.

## `onlyNew` (type: `boolean`):

Return only events not returned by earlier runs with the same sources. Use it for scheduled monitoring.

## Actor input object example

```json
{
  "cities": [
    "san-francisco"
  ],
  "categories": [],
  "calendarUrls": [],
  "eventUrls": [],
  "maxEvents": 5,
  "includeOrganizerDetails": true,
  "onlyNew": false
}
```

# Actor output Schema

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

One row per public Luma event (recordType "event"), with the organizer fields when organizer details are on. A run that could return nothing gives a single explanatory row instead (recordType "status", with status and message).

# 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": [
        "san-francisco"
    ],
    "maxEvents": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("extractlyspace/luma-events-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": ["san-francisco"],
    "maxEvents": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("extractlyspace/luma-events-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": [
    "san-francisco"
  ],
  "maxEvents": 5
}' |
apify call extractlyspace/luma-events-scraper --silent --output-dataset

```

## MCP server setup

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