# Luma Events Scraper (`deriverge/luma-events-scraper`) Actor

Public events from Luma (lu.ma) for any of its 87 cities, an organizer's calendar or a point on the map, with times, venue, price, capacity and guest count. Filter by date, keyword or free entry, or schedule a run that returns only new events.

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

## Pricing

from $0.75 / 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

Luma Events Scraper collects public events from Luma (lu.ma), one row per event: name, start and end in UTC with the event's time zone, venue and address with coordinates, free or ticket price, sold out, spots left, approval and waitlist flags, guest count and the calendar that hosts it. It reads Luma's city pages, organizer calendars or the area around any coordinates, and the form is set to San Francisco. Host names, guest lists and contact details are not collected. It costs $1.50 per 1,000 events on the Free plan ($0.75 on Business), and the $5 of monthly credit in Apify's Free plan covers about 3,300 events.

### Output fields

| Field | Description |
|---|---|
| `name`, `url`, `eventId` | Event title, its page on lu.ma and Luma's event ID, such as `evt-sRV0kpM6G9t9ewk`. |
| `startAt`, `endAt`, `timezone` | Start and end in UTC, and the time zone the event is held in, such as `America/Los_Angeles`. |
| `locationType` | `offline` for events in person, `online` for virtual ones. |
| `venue`, `fullAddress` | Venue name and full street address. Both are empty when the organizer hides the location. |
| `city`, `region`, `country`, `countryCode` | Place of the venue as Luma geocodes it, such as `San Francisco`, `California`, `United States` and `US`. |
| `latitude`, `longitude` | Coordinates of the event in decimal degrees. |
| `isFree`, `price`, `minPrice`, `currency` | Free or paid, the ticket price (the suggested amount for pay-what-you-want), the lowest amount for flexible pricing, and the currency, such as `USD`. |
| `soldOut`, `spotsRemaining`, `nearCapacity` | Sold out, places left when the organizer shows the number, and Luma's almost-full flag. |
| `requiresApproval`, `waitlistActive` | Registration needs the organizer's approval, and new registrations join a waitlist. |
| `guestCount` | Number of registered guests as Luma shows it. Often `0`. |
| `calendarName`, `calendarUrl`, `calendarVerified` | The Luma calendar hosting the event, usually a community or company, its link and Luma's verified mark. For an event run from a person's own account the name is `Personal` and the link is `null`. |
| `hostCount` | How many hosts the event has. Their names are not collected. |
| `eventType` | Luma's event type, such as `independent`. |
| `categories`, `description` | Luma categories such as `AI`, and the description as plain text, both with **Include the description and categories** on. |
| `coverUrl` | Link to the cover image. |
| `source` | The city, calendar or coordinates that found the event, such as `city:sf` or `calendar:genai-sf`. |
| `key` | Row key `luma:<eventId>`, which the new-only mode compares. |

### How to scrape Luma events

1. Add cities to **Cities** by name or by the slug in the city page's link: `San Francisco` or `sf`, `New York` or `nyc`, `London`, `Berlin`.
2. Add **Organizer calendars** as links or slugs, such as `https://lu.ma/genai-sf`, and turn on **Include past events of calendars** for a community's history. For a place without a Luma city page, add **Coordinates** as `latitude,longitude`, such as `50.0875,14.4214` for Prague.
3. Set **Maximum events per source**. The default of 500 is less than a big city lists (see Limits).
4. Filter with **Starts on or after** and **Starts on or before** (`YYYY-MM-DD`, `today`, `tomorrow` or `+7`), **Keywords (any of)** and **Exclude keywords**, which look at the event name and the calendar name, **In person or online** and **Free events only**.
5. Turn on **Include the description and categories** if you need them; each event then takes one more request. Click **Start**, and the events can be exported from the **Output** tab as CSV, Excel or JSON or read through the API.

An API input for the next 30 days of AI and founder events in two cities and one community calendar:

```json
{
  "cities": ["London", "Berlin"],
  "calendars": ["https://lu.ma/genai-sf"],
  "startsAfter": "today",
  "startsBefore": "+30",
  "keywords": ["AI", "founders"],
  "maxEventsPerSource": 2000,
  "includeDescription": true
}
```

### Example output

An event from a run on 11 October 2026 that read the `genai-sf` calendar with descriptions on. The calendar features this event from another organizer, so `calendarName` names the host, Major League Hacking. The `description` is cut after its first two sentences here.

```json
{
  "key": "luma:evt-sRV0kpM6G9t9ewk",
  "eventId": "evt-sRV0kpM6G9t9ewk",
  "name": "Open Intelligence Summit: Hands-On Workshop Day",
  "url": "https://lu.ma/OIS",
  "startAt": "2026-10-12T16:00:00.000Z",
  "endAt": "2026-10-12T21:00:00.000Z",
  "timezone": "America/Los_Angeles",
  "locationType": "offline",
  "venue": "The Midway",
  "fullAddress": "The Midway, 900 Marin St, San Francisco, CA 94124, USA",
  "city": "San Francisco",
  "region": "California",
  "country": "United States",
  "countryCode": "US",
  "latitude": 37.749277400000004,
  "longitude": -122.38569439999998,
  "isFree": true,
  "price": null,
  "minPrice": null,
  "currency": null,
  "soldOut": true,
  "spotsRemaining": null,
  "nearCapacity": false,
  "requiresApproval": false,
  "waitlistActive": false,
  "guestCount": 0,
  "calendarName": "Major League Hacking",
  "calendarUrl": "https://lu.ma/mlhacks",
  "calendarVerified": false,
  "hostCount": 2,
  "eventType": "independent",
  "coverUrl": "https://images.lumacdn.com/uploads/0s/e694dc81-89e9-4d7f-9eb0-9832306c6bf3.png",
  "categories": [
    "AI"
  ],
  "description": "Kick off the Open Intelligence Summit by building.\nThe day before the main Open Intelligence Summit conference, join MLH and DigitalOcean at The Midway for a hands-on workshop day. ...",
  "source": "calendar:genai-sf"
}
```

### How much does it cost to scrape Luma events?

| | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| 1,000 events | $1.50 | $1.20 | $0.975 | $0.75 |

You pay only for the events in the table. There is no start fee, and compute time and proxies are included.

A run that returns 1,000 events costs $1.50 on the Free plan and $0.75 on Business, with or without descriptions. Events removed by a filter, events that a second source finds again and events already returned in new-only mode are not charged.

### Limits

- The cap in **Maximum events per source** applies to every city, calendar or point before filtering, and it is 500 unless you change it. On 11 October 2026 Luma listed 1,162 upcoming events for San Francisco, 1,006 for London, 475 for Berlin and 265 for Singapore.
- The actor reads at most 40 pages of 50 events per source, so a city or a point stops at 2,000 events, and a calendar at 2,000 upcoming and 2,000 past ones.
- A city page covers its region. The San Francisco feed of 11 October 2026 included events in Sunnyvale, Berkeley, Oakland and San Jose.
- Feeds also list events that have already started, such as multi-day summits. **Starts on or after** set to `today` drops them.
- The date filters compare the start date in UTC, so an evening event on the US West Coast counts toward the next day.
- A calendar also lists events it features from other organizers. `calendarName` then names the hosting calendar, and `source` the calendar you asked for.
- Organizers can hide the address: 16 of 50 San Francisco events on 11 October 2026 had no `venue` or `fullAddress`, while their coordinates were filled. `guestCount` was `0` for 17 of the same 50.
- Luma writes some places in the local language, so events in Prague carry `Hlavní město Praha` as the city. `countryCode` is now and then empty when `country` is filled.

### Event alerts

Turn on **Return only events new since the last run**, name the snapshot in **Watch name** (for example `sf-ai-events`; a saved task needs no name) and schedule the run daily. Each run returns only events missing from the snapshot, which remembers an event for 90 days after it was last seen. The `CHANGES` record lists events whose name or start time changed. If **Maximum rows** or the spending limit stops a run, the events it did not reach are not recorded, so the next run returns them.

### FAQ

#### Is it legal to scrape Luma?

The actor reads the event listings that lu.ma shows to visitors who are not signed in. Hosts are often private people, so their names and profiles are not collected: a row gives the number of hosts and the hosting calendar, which was `Personal` for 14 of 50 San Francisco events on 11 October 2026. Event names and descriptions are the organizer's own text and can name speakers or hosts, so treat them as personal data where they do. You are responsible for how you use the data.

#### Which cities can I use?

The 87 cities that had a page on Luma on 11 October 2026, from San Francisco, New York and Toronto to London, Berlin, Dubai, Bengaluru, Singapore, Tokyo, Sydney, São Paulo and Lagos. A city that is not among them is skipped with a warning in the log; give its coordinates instead.

### Related scrapers

- [Meetup Events Scraper](https://apify.com/deriverge/meetup-scraper)
- [Eventbrite Events Scraper](https://apify.com/deriverge/eventbrite-scraper)

### Support

This actor is built and maintained by deriverge s.r.o., a software company based in the Czech Republic. If a run fails or a field you need is missing, please open an issue in the **Issues** tab or write to us at info@deriverge.com. We respond in English and Czech. Runs can be scheduled in Apify Console or started from the **API** tab, which has examples for Python, JavaScript and cURL and works with Make, Zapier, n8n and the Apify MCP server. If the actor saves you time, a short review helps other people find it.

# Changelog

This Actor's version history is a separate document: https://apify.com/deriverge/luma-events-scraper/changelog.md

# Actor input Schema

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

Luma cities by name or slug, for example San Francisco, New York, London, Berlin, Singapore or sf. Luma covers about 90 cities worldwide; each returns the events around it.

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

Luma calendar links or slugs of communities and organizers, for example https://lu.ma/genai-sf. Returns every upcoming event of each calendar.

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

Any other place as latitude,longitude, for example 50.0875,14.4214. Returns the events Luma lists around it.

## `includePastEvents` (type: `boolean`):

Also read the past events of each organizer calendar, for a history of a community.

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

Keep events starting on or after this day: YYYY-MM-DD, today, tomorrow or +7 for a week from now.

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

Keep events starting on or before this day: YYYY-MM-DD, or +30 for a rolling month.

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

Keep only events whose name or organizer contains one of these, for example "AI", "founders" or "yoga".

## `excludeKeywords` (type: `array`):

Drop events whose name or organizer contains any of these.

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

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

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

Keep only events that are free to attend.

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

Opens each event for its full description and Luma categories. Slower; the price is the same.

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

Cap for each city, calendar or coordinate before filtering.

## `newOnly` (type: `boolean`):

Keeps a snapshot per watch name (or per saved task) and returns only events that were not there before. Schedule it daily for an event alert.

## `watchName` (type: `string`):

Name of the snapshot used by the new-only mode, for example "sf-ai-events". Runs from a saved task get one automatically.

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

Hard cap on returned events in the run.

## Actor input object example

```json
{
  "cities": [
    "San Francisco"
  ],
  "includePastEvents": false,
  "locationType": "any",
  "freeOnly": false,
  "includeDescription": false,
  "maxEventsPerSource": 500,
  "newOnly": false,
  "maxItems": 50
}
```

# Actor output Schema

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

One row per event with time, venue, price, capacity, guests and organizer.

## `changes` (type: `string`):

New events and rescheduled or renamed events compared with the previous run of the same task or watch name.

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

Sources read, events found and returned, how many each filter dropped.

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

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

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

```

## MCP server setup

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