# Lu.ma Events Scraper — New Event Alerts (`magnova/luma-events-scraper`) Actor

Search Lu.ma by city, calendar or category — title, start/end with timezone, venue, ticket price and free flag, availability, hosts and categories. Monitoring mode delivers only newly listed events. $0.005 per event, no start fee.

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

## Pricing

from $3.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.
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

## Lu.ma Events Scraper — New Event Alerts

**Find every upcoming event on Lu.ma (lu.ma / luma.com) by city, public calendar or category — and get only the NEW ones on every run after the first.**

Lu.ma is where a large share of tech, AI, startup and community events now live — but it has no public API, no search alerts and no way to watch a city or a calendar for new events. This Actor reads Lu.ma's public place, calendar and category feeds (the same listings its website shows everyone, logged out, no key) and returns clean, structured records — and in monitoring mode it remembers what it has already delivered, so scheduled runs hand you only newly listed events.

**$0.005 per event delivered. No start fee. You never pay for duplicates, filtered-out events, or events already delivered.**

### Sample record (real record, San Francisco place feed, 2026-11-13)

```json
{
  "recordType": "EVENT",
  "eventId": "evt-gQqLCpR7xAzEo05",
  "eventTitle": "Not so European Fridays at European Startup Embassy",
  "eventUrl": "https://lu.ma/w4klnd7l",
  "startDateTime": "2026-11-13T10:00:00",
  "endDateTime": "2026-11-13T18:00:00",
  "startDate": "2026-11-13",
  "timezone": "America/Los_Angeles",
  "venueName": "European Startup Embassy",
  "venueAddress": "European Startup Embassy, 461 Bryant St, San Francisco, CA 94107, USA",
  "area": "China Basin",
  "city": "San Francisco",
  "region": "California",
  "country": "United States",
  "countryCode": "US",
  "isFree": true,
  "isSoldOut": false,
  "spotsRemaining": 12,
  "requiresApproval": true,
  "registrationStatus": "open",
  "waitlistActive": false,
  "calendarName": "European Startup Embassy",
  "calendarSlug": "ESE",
  "hostNames": ["European Startup Embassy"],
  "guestCount": 38,
  "imageUrl": "https://images.lumacdn.com/uploads/j4/56efb675-6ede-4874-ae94-df9c76b4c867.png",
  "source": "luma",
  "categories": ["Tech"],
  "descriptionSnippet": "Come to European Startup Embassy, tell us what you're working on, and get things done before the weekend. Coffee is on us. Rooftop is open. 🌇"
}
```

### What you can search

Combine any of these in one run:

- **Places (cities)** — Lu.ma's 87 discover places: `sf`, `nyc`, `la`, `london`, `austin`, `chicago`, … Use the slug from the place's page URL (lu.ma/sf).
- **Calendars** — any public calendar by its slug (lu.ma/ESE is the European Startup Embassy calendar above).
- **Categories** — `ai`, `tech`, `arts`, `books`, `climate`, `crypto`, `family`, `fitness`, `food`, `games`, `running`, `wellness`.
- **Feed URLs** — paste any lu.ma place, calendar or category page URL directly.

Plus optional filters: a **keyword** (server-side, e.g. "AI" within New York), **free events only**, and a **start-date window** (`dateFrom`/`dateTo`).

### Monitoring mode — only-new delivery

1. Pick (or create) one of your own key-value stores in the **Monitor state store** input.
2. First run with **`monitorOnlyNew` on**: the current matches are recorded silently as the baseline — you are **not charged** for them. (Leave it off and the first run delivers the full corpus instead, charged per event.)
3. Schedule the run (hourly/daily). Every later run delivers — and charges — **only events that were not in the baseline**, and remembers them.

Without a store, every run is a fresh corpus pull. Events are recognised by their stable Lu.ma event ID, so an event that appears in both a city feed and a category feed is delivered once per run, and never again on later runs once a store has seen it.

One honest note: Lu.ma does not publish when an event was listed, so there is no "listed since" date filter — only-new delivery is tracked by the monitor store instead of a listing-date cursor.

### Pricing — $0.005 per event

- **$5.00 per 1,000 events** delivered (SILVER plans $4.25, GOLD and above $3.50). No start fee, no monthly minimum.
- Worked example: a daily watch on New York (71 events in the launch census) costs **$0.36 for the seed-day corpus** if you take it as a corpus run — and with `monitorOnlyNew` the seed is free, so a typical day afterwards with ~8 new events costs **$0.04/day, about $1.20/month**.
- **Not charged:** events already delivered (duplicates within a run or remembered by your monitor store), the silently seeded baseline (`monitorOnlyNew` first run), filtered-out events (keyword / free-only / date window / result cap), ERROR records, and the end-of-run SUMMARY record. Empty runs cost $0.
- Stopping rules built in: `maxResults` caps delivery, and the run stops cleanly at your Apify **maximum total charge** when one is set.

### Use it as an API (Server Actor)

This actor also runs as a **server**: send one HTTP request and get the events back in the response — no run to start, no dataset to poll.

```
POST https://magnova--luma-events-scraper.apify.actor
Authorization: Bearer <YOUR_APIFY_TOKEN>
Content-Type: application/json

{"places": ["sf"], "maxResults": 25}
```

The body takes the same fields as the normal input below. The response is `{"records": [...], "summary": {...}}`. Server mode is a snapshot lookup — the monitor state store stays a scheduled/batch-run feature — and one request returns at most 100 events. You are charged the same $0.005 per delivered event as a normal run (tiered by your Apify plan), billed to your own Apify account; error rows are never charged.

### Use with AI agents (MCP)

This Actor is agent-ready: it is discoverable and runnable through Apify's MCP server, so an AI assistant can call it directly.

- **Tool:** run Actor `magnova/luma-events-scraper` with a JSON input, e.g. `{"places": ["sf"], "maxResults": 100}` for a corpus pull, or add `"monitorOnlyNew": true` plus your key-value store id in `"monitorStore"` for a new-events watch.
- **Output:** one JSON record per event on the default dataset, plus a final `SUMMARY` record with counts (delivered, duplicates skipped, filtered, seeded) — agents can branch on `recordType`.
- **Cost control for agents:** charges accrue per delivered event only; pass `maxResults` (and/or a run-level max charge) to bound spend deterministically.

### Output fields

Population rates measured on a 246-event launch census (San Francisco + New York places, AI + Tech categories, a calendar, keyword and filter runs), 2026-11-13 — a field is only listed with the share it actually showed:

| Field | What it is | On |
|---|---|---|
| `eventId`, `eventUrl` | Lu.ma event ID and its public page | 100% |
| `eventTitle` | Event name as listed | 100% |
| `startDateTime`, `endDateTime`, `startDate` | Local start/end in the event's own timezone | 100% |
| `timezone` | The event's IANA timezone | 100% |
| `city`, `region`, `country`, `countryCode` | From the listing's location block | ~100% |
| `area` | Neighbourhood / sublocality, when published | 88% |
| `venueName`, `venueAddress` | Only when the host publishes the address (many Lu.ma hosts hide it until RSVP) | 62% |
| `isFree` | Free event flag | 100% |
| `ticketPrice`, `ticketPriceMax`, `ticketCurrency` | Cheapest (and priciest) ticket from the listing, where a price is published | 16% (paid events) |
| `isSoldOut`, `registrationStatus` (`open` / `waitlist` / `sold-out`), `waitlistActive`, `requiresApproval` | Availability as listed | 100% |
| `spotsRemaining` | Where the listing shows it | 63% |
| `categories` | The event's Lu.ma categories (AI, Tech, Arts & Culture, …) | 92% |
| `calendarName`, `calendarSlug` | The calendar the event belongs to | 100% / 61% |
| `hostNames` | Host display names as published on Lu.ma | 96% |
| `guestCount` | Guests listed as going | 100% |
| `imageUrl` | Cover image | 100% |
| `descriptionSnippet` | Opening of the event description, contact-shaped text removed | 100% |

Each run also emits one `SUMMARY` record (counts and per-feed status) and one `ERROR` record per feed that could not be read — a bad slug never fails the whole run silently.

### Good to know

- Feed depth is Lu.ma's own: place feeds currently list ~70 upcoming events per major city; category feeds are Lu.ma's curated discover slices (tens of events). What the feed serves is what you get — the SUMMARY reports `resultsFetched` vs `deliveredNew` so you can always reconcile.
- Start/end times are converted into the event's own timezone (a 18:00Z start in Los Angeles is delivered as 10:00 local with `timezone: America/Los_Angeles`).
- Ticket prices come from the listing itself and were verified against the events' own ticket types: `ticketPrice` is the cheapest published ticket, `ticketPriceMax` the most expensive.

### Legal and data note

This Actor reads Lu.ma's public, logged-out listings — the same pages anyone can open — with no login, no API key and no CAPTCHA or access-control bypass. Records carry the events' public facts and the hosts' display names exactly as published; the Actor collects no contact data (no emails or phone numbers — description text is stripped of contact-shaped content before delivery), no social-profile links, and no guest or attendee lists. Event data belongs to its publishers; check Lu.ma's terms and your local rules before reusing it commercially.

# Actor input Schema

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

Lu.ma calendar pages to read, by their slug — e.g. "ESE" (European Startup Embassy) — or a full calendar page URL. A calendar is one community's own event feed. Each calendar is one feed; its upcoming events are delivered.

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

Lu.ma category pages to read, by their slug — the categories Lu.ma itself lists: "ai", "tech", "arts", "books", "climate", "crypto", "family", "fitness", "food", "games", "running", "wellness". A category feed spans every city. Each category is one feed.

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

Optional start-date window start (ISO date, e.g. "2026-11-14"): only events starting on or after this date (in the event's own timezone) are delivered. Must be given together with Date to. Leave both empty for all upcoming events.

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

Optional start-date window end (ISO date, e.g. "2026-11-30"): only events starting on or before this date are delivered. Maximum window: 366 days.

## `feedUrls` (type: `array`):

Whole Lu.ma feed page URLs to read, exactly as you would paste them — any city, calendar or category page (for example "https://lu.ma/sf" or "https://luma.com/ai"). The page itself decides which kind of feed it is. A single event's page is not a feed and returns an ERROR record.

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

On: only events Lu.ma lists as free are delivered (paid events are skipped, never charged). Works on every feed.

## `keyword` (type: `string`):

Optional keyword search run inside every feed (Lu.ma's own feed search — e.g. "hackathon", "AI dinner"). It narrows each feed server-side to matching events. Leave empty for every event in the feed.

## `maxResults` (type: `integer`):

Hard cap on events delivered (and charged) in one run, across all feeds in the run. Events a capped run could not deliver stay unseen in monitoring mode and are delivered by the next run if they still match.

## `maxTotalChargeUsd` (type: `number`):

Optional hard stop for this run's charges: delivery stops as soon as the charged events reach this amount (checked conservatively at the highest per-event price, so the run may stop slightly early on discounted tiers), and the SUMMARY record reports stoppedByMaxCharge. Undelivered new events stay unseen, so the next run delivers them. Leave empty for no cap. The run-level maximum charge in the run options is also honoured exactly.

## `monitorOnlyNew` (type: `boolean`):

Off (default): the first run delivers the feeds' current events as a baseline batch (charged), later runs deliver only new ones. On: the first run silently remembers the current events without delivering or charging anything, and only events listed afterwards are ever delivered. Only applies when a monitor store is selected; without a store every run is a baseline run.

## `monitorStore` (type: `string`):

A key-value store this Actor may read and write to remember which events it has already seen — this is what makes only-new delivery work across runs. Pick any store you own; the Actor keeps one small state record in it. Without a store, every run delivers the feeds' events as a baseline and remembers nothing. If the store is missing or cannot be opened, the run continues in baseline mode and the SUMMARY record says so — it never crashes. The Actor remembers every event it processed (including filtered-out ones), so widening your filters later does not re-deliver old events.

## `places` (type: `array`):

Lu.ma city pages to read, by their page slug — e.g. "sf" (San Francisco), "nyc", "london", "austin". A full page URL ("https://lu.ma/sf") works too. Each place is one feed of that city's upcoming events across every calendar and category. Leave empty when you use Calendars, Categories or Feed URLs instead.

## Actor input object example

```json
{
  "calendars": [
    "ESE"
  ],
  "categories": [
    "ai"
  ],
  "dateFrom": "2026-11-14",
  "dateTo": "2026-11-30",
  "feedUrls": [
    "https://lu.ma/sf"
  ],
  "freeOnly": false,
  "keyword": "hackathon",
  "maxResults": 1000,
  "maxTotalChargeUsd": 1,
  "monitorOnlyNew": false,
  "places": [
    "sf"
  ]
}
```

# Actor output Schema

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

No description

# 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 = {
    "freeOnly": false,
    "maxResults": 100,
    "monitorOnlyNew": false,
    "places": [
        "sf"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("magnova/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 = {
    "freeOnly": False,
    "maxResults": 100,
    "monitorOnlyNew": False,
    "places": ["sf"],
}

# Run the Actor and wait for it to finish
run = client.actor("magnova/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 '{
  "freeOnly": false,
  "maxResults": 100,
  "monitorOnlyNew": false,
  "places": [
    "sf"
  ]
}' |
apify call magnova/luma-events-scraper --silent --output-dataset

```

## MCP server setup

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