# Luma Events Scraper: lu.ma events to JSON (`subimpact/luma-events-scraper`) Actor

Luma (lu.ma) events as JSON from keywords, city pages, calendars or event URLs: start/end, timezone, venue, coordinates, hosts, ticket price range, guest count and full description. From $1.50 per 1,000 events, no start fee.

- **URL**: https://apify.com/subimpact/luma-events-scraper.md
- **Developed by:** [subimpact](https://apify.com/subimpact) (community)
- **Categories:** Social media, Lead generation, Developer tools
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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?

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 to JSON

Public [Luma](https://lu.ma) (lu.ma / luma.com) events as clean JSON, one row per event. Give it search keywords,
city pages, calendar pages or single event URLs — it mixes all four, removes duplicates and stops at your cap.

No browser, no login, no cookies, no API key: the actor calls the same public JSON endpoints the Luma website
itself uses (`api.lu.ma`), so 50 events arrive in seconds using 256 MB of memory.

- **Search** — `"ai startup"`, `"run club"`, `"founders dinner"`… anything Luma's own search finds.
- **Cities** — walk a city's discover page: Singapore, Kuala Lumpur, New York, Berlin, Zurich and the rest.
- **Calendars** — every upcoming event of one organizer calendar.
- **Single events** — one URL, full row (always with the description).

### What one row looks like

| Field | Meaning |
| --- | --- |
| `eventId` | Luma's own event id (`evt-XXXX`), stable — use it to de-duplicate across runs |
| `name` | Event title |
| `url` | Public event URL (`https://lu.ma/<slug>`) |
| `startAt`, `endAt` | Start and end time in UTC, ISO 8601 (`timezone` gives the organizer's local zone) |
| `timezone` | IANA timezone of the event, e.g. `Asia/Singapore` |
| `city` | City of the venue |
| `venueName` | Venue / place name Luma resolved for the event |
| `address` | Full street address |
| `lat`, `lng` | Venue coordinates |
| `isOnline` | `true` for online events |
| `hosts` | Array of host / organizer names |
| `organizerCalendar` | Name of the Luma calendar the event belongs to (`null` for personal one-offs) |
| `organizerCalendarUrl` | `https://lu.ma/<calendar-slug>` when the calendar has a public page |
| `ticketPriceMin`, `ticketPriceMax` | Cheapest and most expensive visible ticket tier in major units (`65` = CHF 65); across all tiers of the event |
| `currency` | ISO code of the ticket prices (`CHF`, `USD`, `SGD`…), `null` when free |
| `isFree` | `true` when Luma reports the event as free |
| `guestCount` | Public guest count, `null` when the organizer hides the guest list |
| `coverImageUrl` | Event cover image |
| `description` | Plain-text description (paragraphs, headings, list items), up to 8,000 characters — with `includeDetails: true` |
| `source`, `sourceType` | Which input produced the row (`search`, `city`, `calendar`, `event-url`) |
| `status` | `ok`, `partial` (detail call failed, core fields still real) or `error` (not charged) |
| `error` | Reason for an error row, or why a row is partial |
| `scrapedAt` | ISO timestamp of the run |

### Example input

Cheapest useful run — 20 events from Singapore, no detail calls:

```json
{
  "cities": ["singapore"],
  "maxEvents": 20,
  "includeDetails": false
}
```

Everything at once:

```json
{
  "searchQueries": ["ai startup", "run club"],
  "cities": ["singapore", "kuala-lumpur", "nyc"],
  "calendarUrls": ["https://lu.ma/readingrhythms-global"],
  "eventUrls": ["https://lu.ma/ciul4l43"],
  "maxEvents": 200,
  "includeDetails": true
}
```

- `cities` takes Luma's own discover slugs — the last part of a city page: `singapore`, `frankfurt`, `zurich`,
  `berlin`, `kuala-lumpur`, `nyc` (New York), `sf` (San Francisco). A full `https://lu.ma/singapore` also works.
  An unknown slug produces one `status: "error"` row that costs nothing, naming the slug format.
- `calendarUrls` takes `https://lu.ma/<calendar-slug>`, a bare slug, or a `cal-XXXX` id.
- `eventUrls` takes `https://lu.ma/<event-slug>`, a bare slug or an `evt-XXXX` id.
- `maxEvents` (default 50, max 2000) is a hard cap for the whole run.
- `includeDetails` (default on) fetches each event once more to fill `description` and the real ticket tiers.
  Turn it off to spend one request per page instead of one per event.

### Example output

A real row from a live run (`{"cities": ["singapore"], "maxEvents": 12}`, description shortened here):

```json
{
  "eventId": "evt-7FyBURpr9MgBbn4",
  "name": "Unconference: Community Day! | 2026",
  "url": "https://lu.ma/4ibqnsto",
  "startAt": "2026-11-15T04:00:00.000Z",
  "endAt": "2026-11-15T13:00:00.000Z",
  "timezone": "Asia/Singapore",
  "city": "Singapore",
  "venueName": null,
  "address": null,
  "lat": 1.2988922845254298,
  "lng": 103.83483256641982,
  "isOnline": false,
  "hosts": ["3 of Us"],
  "organizerCalendar": null,
  "organizerCalendarUrl": null,
  "ticketPriceMin": null,
  "ticketPriceMax": null,
  "currency": null,
  "isFree": true,
  "guestCount": 85,
  "coverImageUrl": "https://images.lumacdn.com/uploads/eo/bcd18291-eee6-4ec7-8481-7c52e821e11a.png",
  "description": "3 of Us is hosting our THIRD Unconference! And we're inviting you! :D\n\nWhat is an Unconference?\n\nAn Unconference is the opposite of a conference…",
  "source": "singapore",
  "sourceType": "city",
  "status": "ok",
  "error": null,
  "scrapedAt": "2026-11-14T19:30:09.573Z"
}
```

### Pricing

**$1.50 per 1,000 events** — one charge per event row delivered, no start fee. You pay only for events that
actually land in your dataset: `status: "error"` rows (an unknown city slug, a deleted event URL) are free.

### Good to know

- **Only public events.** Private events, unlisted events and invite links that need a session are not returned —
  the actor never logs in and sends no cookies.
- **Hidden details stay hidden.** Luma lets organizers hide the guest list and the exact address (the address is
  often revealed only after RSVP). Those rows have `guestCount: null` and `venueName`/`address: null`; the
  coordinates are still filled when Luma exposes them.
- **Online events** are flagged by the organizer's own setting (`isOnline`). Many organizers describe an online
  webinar in the text without setting the flag, so treat `isOnline: false` as "not marked online", not as proof of
  a physical venue.
- **Recurring events** come back as separate rows, one per occurrence (each with its own `eventId` and dates).
- **Past events** are not walked: city and calendar sources return upcoming events only. A past event URL given
  explicitly still returns its row.
- **No proxy by default.** Luma's public API answers plain requests at full speed. If your runs ever start seeing
  403/429 answers, switch `proxyConfiguration` on — the actor retries 429/5xx twice either way.

### Notes on sources

- `search` = Luma discover search, paginated 50 per page.
- `city` = the city's discover page, resolved through Luma's place lookup first, then paginated.
- `calendar` = the calendar's upcoming events (`period=future`).
- `event-url` = the single event, read from the page's own bootstrap data (no second call needed).
- The same event found by two sources is delivered once; duplicates inside a run are skipped.

# Actor input Schema

## `searchQueries` (type: `array`):

Keyword searches on Luma's own discover search, e.g. "ai startup", "run club", "founders dinner". Each query is paginated until maxEvents is reached.

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

Luma discover city slugs, i.e. the last part of a luma.com city page: singapore, frankfurt, zurich, berlin, kuala-lumpur, nyc (New York), sf (San Francisco). A full URL such as https://lu.ma/singapore also works.

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

Luma calendar pages, e.g. https://lu.ma/readingrhythms-global (or just the slug, or a cal-XXXX id). Returns the calendar's upcoming events.

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

Individual Luma event URLs, e.g. https://lu.ma/ciul4l43 (a bare slug or an evt-XXXX id also works). These are fetched first and always carry the full description.

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

Hard cap for the whole run (1-2000). You pay per delivered event, so the default 50 costs about $0.08.

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

On (default): one extra API call per event fills description and the real min/max ticket price. Off: one request per page instead of one per event (cheapest, fastest), description stays null.

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

No proxy by default — Luma's public API answers plain requests. Enable Apify Proxy only if your runs start getting 403/429 answers.

## Actor input object example

```json
{
  "searchQueries": [
    "ai startup",
    "run club"
  ],
  "cities": [
    "singapore",
    "nyc",
    "kuala-lumpur"
  ],
  "calendarUrls": [
    "https://lu.ma/readingrhythms-global"
  ],
  "eventUrls": [
    "https://lu.ma/ciul4l43"
  ],
  "maxEvents": 50,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per event: eventId, name, url, startAt/endAt (UTC, ISO), timezone, city, venueName, address, lat, lng, isOnline, hosts, organizerCalendar, organizerCalendarUrl, ticketPriceMin/Max, currency, isFree, guestCount, coverImageUrl, description (when includeDetails), source, sourceType, status (ok/partial are charged, error rows are free) and scrapedAt.

# 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": [
        "singapore"
    ],
    "maxEvents": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("subimpact/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": ["singapore"],
    "maxEvents": 50,
}

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

```

## MCP server setup

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