# Luma Events Scraper — Events by City, Category & Calendar (`nexgensignal/luma-events-scraper`) Actor

Public events from Luma (lu.ma) by city, category, coordinates or calendar: dates, venue and address, ticket prices, capacity, guest count, organiser, optional description. Many cities in one run. Hosts are not named. Part of NexGen Signal — data tools and official-source data products

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

## Pricing

from $33.50 / 1,000 event listings

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 — Events by City, Category & Calendar

Export **public events from Luma** (luma.com, formerly lu.ma) as clean rows: name, start and end in UTC with the timezone, in person or online, venue and full address, coordinates, free or ticket price range, sold out, spots left, approval required, guest and ticket counts, organiser and its Luma page, cover image and, optionally, the full description.

Ask in four ways, as many as you like in one run: **cities** (about 90 Luma discovery cities — New York, San Francisco, London, Berlin, Tokyo, Toronto…), **categories** near those cities (tech, ai, arts, fitness, wellness, climate, crypto, food, books, games, family, running), **coordinates** for any other place, and **calendars** (a community's or venue's Luma page, upcoming or past). Filter by dates, free only, and in person or online.

The unit of output is one event delivered. Hosts and guests are people and are never named.

### Who buys this and for what job

- **Event sponsors and sales teams** finding tech and AI meetups in their target cities.
- **Community and DevRel teams** tracking what competitors and communities run.
- **Newsletters and city guides** listing upcoming events.
- **Researchers** counting events by city and topic.

Buyers usually search for this as **"Luma scraper"**, **"lu.ma events"** or **"tech events by city"**.

### 📊 Sample Output

![Table of Luma events: name, city, start time, price, guests and organiser.](https://api.apify.com/v2/key-value-stores/IXCaMKjxSmUTLHhmq/records/luma-events-scraper.png)

| event | city | starts | price | guests | organizer |
|---|---|---|---|---|---|
| SOFA RUN CLUB Ep. 1 | New York | 2026-10-18 14:00 | Free | 141 | (personal) |
| Reading Club: Aristotle's Ethics | New York | 2026-10-18 15:00 | 25 USD | 77 | The New York Philosophy Club |
| The Pop-Up Care Shop x City Girls Who Care C | New York | 2026-10-18 15:30 | Free | 150 | City Girls Who Care |
| precious plushie taxidermy | Kings County | 2026-10-18 16:00 | 38 USD | 0 | welcome to the craftnook |
| new interfaces 007 | New York | 2026-10-18 17:00 | Free | 169 | new interfaces |
| First Light:AAPI Film Festival | Brooklyn | 2026-10-18 19:00 | 20 USD | 113 | (personal) |
| Girls Girls Club: Victoria's Secret FASHION  | New York | 2026-10-18 22:30 | 80 USD | 0 | Girls Girls Club |
| Claude & Chill for Founders & Creators | New York | 2026-10-19 21:15 | Free | 0 | Claude Community Events |

Rows from live run `e2TLjf6nWsiJbJa6I` on Apify (New York, Berlin and Tokyo discovery lists, 40 events). Notice '(personal)': events on a person's own calendar are delivered without naming the person.

### ✅ What you get

Every field of each record:

- `record_id`, `event_id`, `name`, `event_url` — the event and its luma.com page.
- `start_at`, `end_at`, `timezone`, `location_type` — when, and in person or online.
- `venue_name`, `address`, `city`, `region`, `country`, `country_code`, `latitude`, `longitude`, `address_visibility` — where (the full address only when Luma shows it publicly).
- `is_free`, `price_min`, `price_max`, `currency`, `flexible_price` — price.
- `sold_out`, `spots_remaining`, `near_capacity`, `requires_approval`, `registration_status`, `waitlist_active` — availability.
- `guest_count`, `ticket_count`, `host_count` — counts only.
- `organizer_name`, `organizer_url`, `organizer_verified`, `personal_calendar` — the organising community or calendar (not named when it is a person's own calendar).
- `cover_image_url`, `description_text` — cover image; description as plain text (includeDescription).
- `found_via`, `source_url`, `read_at` — which city, category, point or calendar found it; page; when read.

### ⚙️ Sample inputs

**AI events in San Francisco and London (the Store example)**

```json
{
  "cities": ["San Francisco", "London"],
  "categories": ["ai"],
  "maxEvents": 10
}
```

**Everything listed in three cities**

```json
{
  "cities": ["New York", "Berlin", "Tokyo"],
  "maxEvents": 1000
}
```

Each city's Luma discovery list.

**Tech events near Barcelona next month, free only**

```json
{
  "coordinates": ["41.3874,2.1686"],
  "categories": ["tech"],
  "startAfter": "2026-11-01",
  "startBefore": "2026-11-30",
  "freeOnly": true
}
```

**A community's past events with descriptions**

```json
{
  "calendars": ["https://luma.com/southparkcommons-events"],
  "calendarPeriod": "past",
  "includeDescription": true,
  "maxEvents": 200
}
```

Input fields:

| Field | Meaning |
|---|---|
| `cities` | Luma discovery cities by name. |
| `categories` | with cities or coordinates: that category's events nearby. |
| `coordinates` | 'lat,lon' points; need a category. |
| `calendars`, `calendarPeriod` | Luma calendar names or links; upcoming (future) or past events. |
| `startAfter`, `startBefore`, `freeOnly`, `locationType` | date range, free only, in person / online. |
| `includeDescription` | add the full description (one extra request per event). |
| `maxEventsPerSource` | events per city, category or calendar (default 500). |
| `maxEvents` | stop after this many events (default 1,000). Each delivered event is billed. |

### 🧾 JSON sample record

```json
{
  "record_id": "94d4d733a5cafd8f33bc7a48",
  "event_id": "evt-UtPPeX7Pm7dTPQJ",
  "name": "TL/IRL: AI for Security & Security for AI [Georgian x AISecEng]",
  "event_url": "https://luma.com/tlirl-ai-security",
  "start_at": "2026-10-20T21:30:00.000Z",
  "end_at": "2026-10-21T00:30:00.000Z",
  "timezone": "America/Toronto",
  "location_type": "in_person",
  "venue_name": null,
  "address": null,
  "city": "Toronto",
  "region": "Ontario",
  "country": "Canada",
  "country_code": "CA",
  "latitude": null,
  "longitude": null,
  "address_visibility": "guests_only",
  "is_free": true,
  "price_min": null,
  "price_max": null,
  "currency": null,
  "flexible_price": null,
  "sold_out": true,
  "spots_remaining": 0,
  "near_capacity": false,
  "requires_approval": true,
  "registration_status": "waitlist",
  "waitlist_active": true,
  "guest_count": 0,
  "ticket_count": 0,
  "host_count": 6,
  "organizer_name": "Georgian",
  "organizer_url": "https://luma.com/georgian",
  "organizer_verified": false,
  "personal_calendar": false,
  "cover_image_url": "https://images.lumacdn.com/uploads/7t/d3e94129-af69-4e7b-89a4-2ee6a7d75a49.jpg",
  "description_text": "AI is a powerful security tool, but it's also a new attack surface! 🔐\n\nOpen models can help hunt for vulnerabilities in your code and dependencies, but they also bring risks of their own, from missing guardrails to a compromised supply chain. The AI products we build on top of them need permissions and boundaries that hold up in production, especially as agents adopt skills that can introduce mali…",
  "found_via": "city:Toronto|category:ai",
  "source_url": "https://luma.com/tlirl-ai-security",
  "read_at": "2026-10-18T02:51:08Z"
}
```

### 🔧 How it works

The actor reads Luma's public discovery list and calendar pages through the same JSON endpoints luma.com uses, 50 events per request with a pause between requests. Luma ignores a category combined with a city name, so a city + category search uses the city's coordinates. An event found by two of your searches is delivered once.

Addresses Luma shows only to registered guests stay hidden (city only). Hosts, guests and featured guests are never read into rows; a personal calendar's owner is not named.

Every run reads each host's robots.txt first: a path it disallows is skipped, listed in the run receipt and never charged. Only public internet addresses are fetched (no private, loopback or cloud-metadata addresses, checked again on every redirect). No logins, no CAPTCHA solving, no proxies.

Delivery is pushed first and charged after. The run receipt (`RUN_RECEIPT`) lists every source with events read and kept, unknown city names with Luma's full city list, how many events each filter dropped, and the delivered and charged counts.

### 💰 Pricing example

Per event delivered, no start fee, no monthly charge:

| Apify plan | Price per event |
|---|---|
| Free | $0.05 |
| Bronze | $0.045 |
| Silver | $0.04 |
| Gold, Platinum, Diamond | $0.0335 |

- 10 events: $0.50 on the Free plan, $0.34 on Gold.
- 1,000 events: $50.00 on the Free plan, $33.50 on Gold.
- 10,000 events: $500.00 on the Free plan, $335.00 on Gold.

**Coverage and size.** Proof runs on 18 Oct 2026: 40 events from three cities in 5 seconds; Toronto + AI, a point in Barcelona + AI and a community calendar, with descriptions, 18 events in 18 seconds. City discovery lists hold the events Luma features for each city (New York listed 75 that day); categories and calendars reach many more.

### ⚖️ Legal & ToS

Events are published by their organisers on Luma. Luma's terms of use carry a copyright notice and no clause against automated access; robots.txt on luma.com and on its data host (api2.luma.com) allows these pages. Use the data for listing and research, and link to the event page.

No person data: hosts and guests are counted, never named.

Every run reads each host's robots.txt first: a path it disallows is skipped, listed in the run receipt and never charged. Only public internet addresses are fetched (no private, loopback or cloud-metadata addresses, checked again on every redirect). No logins, no CAPTCHA solving, no proxies.

### ❓ FAQ

**My city is not found**
Luma has about 90 discovery cities (listed in RUN_RECEIPT). For other places use coordinates with a category.

**Can I get the guest list?**
No. Guests are people; only counts are delivered.

**Do I need a Luma account?**
No.

### 🆘 Troubleshooting

- **PARTIAL with 'not Luma discovery cities'** — Those names did not match; see the city list in RUN_RECEIPT.
- **SOURCE UNAVAILABLE** — Luma did not answer after retries. Nothing was charged.

### 🔗 Related Actors

- [Recently Funded Startups](https://apify.com/nexgensignal/funding-round-intelligence-api) — who just raised money and may sponsor events
- [Company Email Lookup by Domain](https://apify.com/nexgensignal/business-email-discovery-api) — reach an organiser's company from its domain
- [CMS & Hosting Detector](https://apify.com/nexgensignal/website-tech-stack-api) — what an organiser's site is built with

🏢 **About NexGen Signal** — data tools and official-source data products. Browse the catalog: [apify.com/nexgensignal](https://apify.com/nexgensignal)

### ⭐ Found this useful?

If this actor saved you time, a rating on its Apify Store page helps other buyers find it.

Part of NexGen Signal — data tools and official-source data products.

# Actor input Schema

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

Luma discovery cities by name, e.g. New York, San Francisco, London, Berlin, Tokyo, Toronto (about 90 cities; unknown names are listed in the receipt with the full list).

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

Luma categories. With cities: that category's events near each city. With coordinates: near that point. Empty = each city's full discovery list.

## `coordinates` (type: `array`):

'latitude,longitude' points (e.g. 41.3874,2.1686) for places that are not Luma discovery cities. Needs at least one category.

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

Luma calendar names or links, e.g. https://luma.com/southparkcommons-events — returns the calendar's upcoming events.

## `calendarPeriod` (type: `string`):

Upcoming or past events for the calendars above (past = event history, newest first).

## `startAfter` (type: `string`):

Date like 2026-11-01.

## `startBefore` (type: `string`):

Date like 2026-11-30.

## `freeOnly` (type: `boolean`):

Keep only free events.

## `locationType` (type: `string`):

Keep in-person events, online events, or both.

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

Add each event's full description as plain text (one extra request per event).

## `maxEventsPerSource` (type: `integer`):

Read at most this many events from each city, category or calendar.

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

Stop after this many events. Each delivered event is billed.

## Actor input object example

```json
{
  "cities": [
    "San Francisco",
    "London"
  ],
  "categories": [
    "ai"
  ],
  "coordinates": [],
  "calendars": [],
  "calendarPeriod": "future",
  "freeOnly": false,
  "locationType": "all",
  "includeDescription": false,
  "maxEventsPerSource": 500,
  "maxEvents": 10
}
```

# Actor output Schema

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

The delivered (and billed) records.

## `receipt` (type: `string`):

Per-link outcome, robots result, delivered and charged counts.

# 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",
        "London"
    ],
    "categories": [
        "ai"
    ],
    "maxEvents": 10
};

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

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

```

## MCP server setup

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