# Luma Events Scraper — Cities, Categories, Tickets, Guests (`chorelet/luma-events-scraper`) Actor

Events from lu.ma by city, category, keyword or URL: name, date, venue and coordinates, host calendar, ticket price, free or paid, sold out, approval and registered guests. No login, CSV/JSON export and API.

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

## Pricing

from $1.40 / 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 Events Scraper — Cities, Categories, Tickets, Guests

Every public event on **lu.ma** for a city, a category or a keyword — with date, venue and coordinates, the host calendar, ticket price, whether it is free, sold out or approval-only, and how many people have registered. As JSON, CSV or Excel, or through the API.

Luma is where most AI, crypto and startup meetups live now, and its events rarely appear on Eventbrite or Meetup. No account, no login: the Actor reads the same public discover API the website uses.

### Why this Actor

- **Where the meetups actually are.** AI, crypto and startup events moved to Luma; most of them never appear on Eventbrite or Meetup.
- **Money and demand in the row.** Ticket price, free or paid, sold out, approval required, spots left and registered guests — not just a title and a date.
- **Follow organisers, not events.** Every row carries the host calendar, so you can watch a series instead of re-searching every week.
- **City, category, keyword or URL.** Four ways in, one schema out, and a date window so a daily run returns only what is new.

### Sample output

One item of the dataset (long values shortened):

```json
{
  "name": "Barbarossa Closing Party",
  "startAt": "2026-09-26T05:00:00.000Z",
  "addressRegion": "San Francisco, CA",
  "isOnline": false,
  "isFree": false,
  "price": 10,
  "guestCount": 709,
  "calendarName": "SFVibe",
  "url": "https://lu.ma/barbarossa"
}
```

### What you get

- Search by city (87 Luma discover cities), by category (`ai`, `tech`, `crypto`, `arts`, `climate`, …), by keyword, or by event URL
- Venue, city, country and coordinates where the host publishes them
- Ticket price and currency, free/paid, sold out, approval required, spots left
- Registered guests and tickets issued where the host shows them
- Host calendar — the series an event belongs to, so you can follow the organiser, not just the event
- Monitored daily

### Input

- **Cities** — `San Francisco`, `New York`, `London`, `Berlin`, `Bangalore`… The Actor matches against Luma's own city list and says so if a city is not covered.
- **Categories** — `ai`, `tech`, `crypto`, `arts`, `climate`, `fitness`, `wellness`, `food`, `games`, `books`, `running`, `family`.
- **Keywords** — `hackathon`, `demo day`, `founders`… Each keyword is its own search and combines with a city.
- **Event URLs** — `https://lu.ma/abc123` for specific events, always with full details.
- **Starts after / Starts before**, **Online events only**, **Max events per search**, **Include ticket info and guest counts**.

### Limits and notes

- Luma's discover feed covers **upcoming** events only. Past events are reachable by URL, not by search.
- Some hosts hide the exact address until you register — then `venue` is null and only the city is public. The same goes for guest counts on private guest lists.
- One search is one city × category × keyword combination; ten cities × two categories is twenty searches, and the max applies to each.
- Ticket details need one extra request per event. Turn them off for a quick list of what is on.

### Input example

```json
{
  "cities": [
    "San Francisco"
  ],
  "categories": [
    "ai"
  ],
  "startsBefore": "30 days",
  "onlineOnly": false,
  "maxEvents": 50,
  "includeDetails": true
}
```

### How much does it cost?

Pay per event — no subscription, no minimum, no charge for platform usage.

| Volume | Price |
|---|---|
| 1,000 events | $2.00 (+ $1.00 with `details`) |
| 10,000 events | $20.00 (+ $10.00 with `details`) |
| 100,000 events | $200.00 (+ $100.00 with `details`) |

The Apify **free plan includes $5 of usage every month** — about 2,500 events with this Actor, no card needed. Nothing else is charged: platform usage is included in the price, and Apify Bronze, Silver and Gold subscribers get 10%, 20% and 30% off these prices.

### Use it from code, n8n, Make, Zapier or an AI agent

Run the Actor and download the dataset in one call (JSON by default; add `&format=csv` or `xlsx`):

```bash
curl -X POST "https://api.apify.com/v2/acts/chorelet~luma-events-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"cities": ["San Francisco"], "categories": ["ai"], "startsBefore": "30 days", "onlineOnly": false, "maxEvents": 50, "includeDetails": true}'
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("chorelet/luma-events-scraper").call(run_input={"cities": ["San Francisco"], "categories": ["ai"], "startsBefore": "30 days", "onlineOnly": false, "maxEvents": 50, "includeDetails": true})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

- **n8n, Make, Zapier** — use the Apify node/module: run the Actor, then "get dataset items".
- **Google Sheets, Slack, webhooks** — add an integration on the run's *Integrations* tab.
- **AI agents** — the Actor is available as a tool through the Apify MCP server; the dataset schema describes every field for the model.
- **Schedules** — run it hourly, daily or weekly from the *Schedules* tab.

### FAQ

**Which cities are covered?**

The 87 cities Luma itself lists on lu.ma/discover — the big tech hubs and most European and Asian capitals. Write the city name as Luma writes it (`San Francisco`, `New York`, `London`); the run log tells you if a city is not in the list.

**Can I get past events?**

Not through search — Luma's discover feed is upcoming-only. A past event is still readable by its URL through the *Event URLs* field.

**Why is the venue empty for some events?**

Many hosts publish the exact address only to registered guests. In that case Luma exposes the city but not the street, and the Actor returns null rather than guessing.

**How do I watch a city weekly?**

Put the city in, set *Starts before* to `7 days`, schedule it weekly and let the dataset accumulate — or run it daily and deduplicate on `eventId`.

**Is an account needed?**

No. Everything comes from the public discover and event endpoints that lu.ma serves to anonymous visitors.

### Support

Questions, missing fields or a source that changed? Open an issue on the *Issues* tab or write to support@chorelet.app — problems are usually fixed within a day, and the Actor is checked every morning by an automated test run. If the Actor saved you time, a short review on its Store page helps other people find it.

# Actor input Schema

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

Luma discover cities, e.g. `San Francisco`, `New York`, `London`, `Berlin`, `Bangalore`. The Actor matches the name against Luma's own list and tells you if a city is not covered.

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

Luma categories: `ai`, `tech`, `crypto`, `arts`, `climate`, `fitness`, `wellness`, `food`, `games`, `books`, `running`, `family`. Empty = all.

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

Search terms, e.g. `hackathon`, `demo day`, `founders`. Each keyword is a separate search and can be combined with a city.

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

Specific events to fetch: `https://lu.ma/abc123` or the bare slug. Always returned with full details.

## `startsAfter` (type: `string`):

Keep events starting after this point: `2026-10-01` or relative `2 days`. Empty = from now on.

## `startsBefore` (type: `string`):

Keep events starting before this point: `2026-12-31` or relative `30 days`.

## `onlineOnly` (type: `boolean`):

Keep only virtual events.

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

A search is one city × category × keyword combination.

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

One extra request per event: price, free/paid, sold out, approval required, spots left, registered guests, host calendar. Charged separately.

## Actor input object example

```json
{
  "cities": [
    "San Francisco"
  ],
  "categories": [
    "ai"
  ],
  "keywords": [],
  "eventUrls": [],
  "startsBefore": "30 days",
  "onlineOnly": false,
  "maxEvents": 50,
  "includeDetails": true
}
```

# Actor output Schema

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

All events — items of the default dataset. Use ?format=csv or xlsx on this URL for spreadsheets.

## `summary` (type: `string`):

Events per search, details fetched, and errors.

# 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"
    ],
    "categories": [
        "ai"
    ],
    "keywords": [],
    "eventUrls": [],
    "startsAfter": "",
    "startsBefore": "30 days",
    "onlineOnly": false,
    "maxEvents": 50,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("chorelet/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"],
    "categories": ["ai"],
    "keywords": [],
    "eventUrls": [],
    "startsAfter": "",
    "startsBefore": "30 days",
    "onlineOnly": False,
    "maxEvents": 50,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("chorelet/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"
  ],
  "categories": [
    "ai"
  ],
  "keywords": [],
  "eventUrls": [],
  "startsAfter": "",
  "startsBefore": "30 days",
  "onlineOnly": false,
  "maxEvents": 50,
  "includeDetails": true
}' |
apify call chorelet/luma-events-scraper --silent --output-dataset

```

## MCP server setup

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