# Luma Events Scraper: lu.ma Events to JSON

The Luma Events Scraper returns one row per public lu.ma event with name, URL, start and end in UTC, the organiser's IANA timezone, city, venue name and address, coordinates, online flag, hosts, organiser calendar, ticket price range, currency, free flag, guest count and cover image. Sources can be keywords, city pages, calendars and single event URLs in one run. Events cost $1.50 per 1,000. Run it from Apify Console or the API.

## Key facts

- Price: from $0.0015 per event scraped, $1.50 per 1,000, down to $0.001 on higher Apify plans
- Pricing model: Pay per event
- Output: JSON, CSV, Excel, XML, RSS via Apify datasets
- Access: Apify Console, REST API, Python and JS clients
- Version: Updated Nov 2026, build 0.1.2
- Actor: subimpact/luma-events-scraper

## Who it is for

- Community managers tracking what else is happening in their city
- Event marketers scouting venues and price points for a launch
- Newsletter writers sourcing upcoming tech and founder events
- Researchers mapping a scene through calendars and guest counts

## Use cases

### Walk a city's upcoming events

Set cities to luma discover slugs such as singapore, kuala-lumpur, nyc or berlin, or paste a full https://lu.ma/singapore URL, then cap with maxEvents. Rows carry city, venueName, address, lat and lng, so the list can be sorted by distance or plotted on a map. City sources return upcoming events only, so the run stays current.

### Find events by keyword

Put phrases in searchQueries such as ai startup, run club or founders dinner. Luma's own discover search is paginated until maxEvents is reached, and each row records source and sourceType as search, so keyword results stay distinguishable from city or calendar pulls in a merged export. The same event found twice is delivered once.

### Follow one organiser calendar

Pass a calendar URL such as https://lu.ma/readingrhythms-global, a bare slug or a cal id, and the actor returns that calendar's upcoming events. Rows carry organizerCalendar and organizerCalendarUrl fields, which is enough to group a merged dataset by organiser and see who is running the most frequent events in a scene.

### Compare ticket prices across events

ticketPriceMin, ticketPriceMax and currency come from the visible ticket tiers, and isFree flags events without a priced tier. With includeDetails on you also get the real tier range rather than the placeholder on the listing. That lets you benchmark a price for a workshop against comparable events in the same city.

### Gauge interest from guest counts

guestCount is the public guest count, and it is null where an organiser hides the list. Sorting a city's events by guestCount shows which formats pull a crowd, though treat hidden counts as unknown rather than zero. Coordinates still fill in even when the exact address is withheld until RSVP.

## Price events

- Event scraped (`event-scraped`): $0.0015, lowest tier $0.001. One public Luma event delivered as a dataset row (id, name, URL, times, venue, coordinates, hosts, calendar, ticket prices, guest count, cover image, description when includeDetails is on). Platform usage included. Error rows are free.

Prices from the Apify Store. Apify shows the final price before each run.

## How it compares with other Apify actors

Price per 1,000 events at Apify Store list prices, checked 20 Nov 2026.

| Actor | Price per 1,000 events (Free plan) | Higher plans (Gold) | Start fee per run | Platform usage | Users | Rating | Last build |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Luma Events Scraper: lu.ma events to JSON (this API) | $1.50 | $1.00 | None | Included | 1 | No reviews yet | 18 Nov 2026 |
| [Luma Event Scraper](https://apify.com/solidcode/luma-scraper) | $3.00 | $2.50 | $0.00005 | Included | 282 | No reviews yet | 22 Aug 2026 |
| [Luma Event Scraper](https://apify.com/matyascimbulka/luma-event-scraper) | $0.07 | $0.03 | $0.00005 | Included | 252 | 5.0 (1 review) | 22 Feb 2026 |
| [Event Scraper Pro](https://apify.com/webdatalabs/event-scraper-pro) | $20.00 | $14.00 | $0.00005 | Included | 183 | 4.0 (5 reviews) | 22 Sep 2026 |
| [Eventbrite, Lu.ma & Meetup [$0.99] Events + Organizer Leads](https://apify.com/memo23/eventbrite-scraper) | $0.99 | $0.99 | $0.025 | Included | 128 | No reviews yet | 16 Nov 2026 |

### Where Luma Event Scraper is stronger

- Larger user base and more monthly runs than the other Luma actors here
- Filters for category, event type, pricing and a date window
- Covers the global discover feed as well as city and calendar pages

### Where this API is stronger

- No start fee is added to a run
- Rows carry venue latitude and longitude
- Event URLs and calendar URLs can be mixed in the same run

### Where Luma Event Scraper is stronger

- Quick city and category sweep from a very simple input
- Organizer and attendance fields sit in each event row
- Lightweight input surface for repeat city runs

### Where this API is stronger

- Keyword search and event URL input alongside cities
- Rows carry coordinates, ticket price range and the description
- Calendar pages can be used as a source too

### Where Event Scraper Pro is stronger

- Combines Meetup, Luma and Eventbrite into one deduplicated dataset
- Optional calendar file and webhook delivery
- Reports which searches completed on every run

### Where this API is stronger

- Focused on Luma alone, so rows keep Luma specific detail
- Keyword, city, calendar and event URL inputs live in one actor
- No start fee is added to a run

### Where Eventbrite, Lu.ma & Meetup [$0.99] Events + Organizer Leads is stronger

- Organizer enrichment adds website, socials and best effort email
- Monitoring mode returns only events not seen on earlier runs
- City, category, date and price filters work across three platforms

### Where this API is stronger

- Keeps Luma specific fields such as guest count and the calendar link
- No start fee is added to a run
- Search queries, cities, calendars and event URLs in one input

Luma event scraping is a small field with two dedicated actors and two multi platform tools. solidcode offers the widest filter set, matyascimbulka keeps a simple city and category sweep, webdatalabs deduplicates Luma with Meetup and Eventbrite, and memo23 adds organizer lead enrichment. Ours bills per event with no start fee.

Prices are Apify Store list prices, checked 20 Nov 2026. Platform usage 'Paid separately' means Apify bills compute on top of the event price. Check each listing before you buy.

## Input

- `searchQueries` (array, optional): 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` (array, optional): 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` (array, optional): 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` (array, optional): 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` (integer, optional): Hard cap for the whole run (1-2000). You pay per delivered event, so the default 50 costs about $0.08.
- `includeDetails` (boolean, optional): 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` (object, optional): No proxy by default — Luma's public API answers plain requests. Enable Apify Proxy only if your runs start getting 403/429 answers.

### Example input

```json
{
  "cities": [
    "singapore"
  ],
  "maxEvents": 50
}
```

## Output fields

- `eventId` (string/null): Luma's own event id (evt-XXXX). Use it to de-duplicate across runs.
- `name` (string/null): 
- `url` (string/null): Public Luma event URL (https://lu.ma/<slug>).
- `startAt` (string/null): Start time in UTC, ISO 8601 (the local time is derived with timezone).
- `endAt` (string/null): End time in UTC, ISO 8601. null for events without an end time.
- `timezone` (string/null): IANA timezone the organizer set for the event, e.g. Asia/Singapore.
- `city` (string/null): City of the venue as Luma stores it. null for online events without a location.
- `venueName` (string/null): Venue / place name, e.g. the venue Luma resolved from Google Places. null when the event only has a plain address.
- `address` (string/null): Full street address, e.g. "claw collective, Bederstrasse 109, 8002 Zürich, Switzerland".
- `lat` (number/null): 
- `lng` (number/null): 
- `isOnline` (boolean/null): true when the organizer marked the event as an online event (Luma location_type = online).
- `hosts` (array/null): Names of the visible hosts / organizers. null when the entry exposes none.
- `organizerCalendar` (string/null): Name of the Luma calendar the event belongs to (null for personal one-off events).
- `organizerCalendarUrl` (string/null): https://lu.ma/<calendar-slug> when the calendar has a public slug, else null.
- `ticketPriceMin` (number/null): Cheapest visible ticket tier in major currency units (45 = CHF 45). null for free events and for events without prices.
- `ticketPriceMax` (number/null): Most expensive visible ticket tier in major currency units. Equal to the min for single-tier events.
- `currency` (string/null): ISO 4217 code of the ticket prices, upper case (CHF, USD, EUR, SGD). null when the event is free or has no priced tier.
- `isFree` (boolean/null): true when Luma reports the event as free (no priced ticket tier).
- `guestCount` (integer/null): Number of guests Luma exposes publicly. null when the organizer hides the guest list.
- `coverImageUrl` (string/null): 
- `description` (string/null): Plain-text event description (paragraphs, headings and list items in document order), up to 8,000 characters. Only filled when includeDetails is on.
- `source` (string/null): The input value this row came from (the search query, city slug, calendar URL or event URL).
- `sourceType` (string/null): search, city, calendar or event-url.
- `status` (string/null): ok: full row (charged). partial: the event was delivered but its detail call failed, so description is null (charged, the core fields are real). error: the source failed or the entry was unusable (NOT charged).
- `error` (string/null): Reason for an error row, or the reason a partial row has no description. null on ok rows.
- `scrapedAt` (string/null): ISO timestamp of the run.

## Sample output

Trimmed from one of our own test runs. Personal data is redacted.

```json
[
  {
    "eventId": "evt-OBlx2ZrWbLMSpNY",
    "name": "Codex Community Meetup - Singapore",
    "url": "https://lu.ma/codexsg-nov20",
    "startAt": "2026-11-20T10:00:00.000Z",
    "endAt": "2026-11-20T14:00:00.000Z",
    "timezone": "Asia/Singapore",
    "city": "Singapore",
    "venueName": null,
    "address": null,
    "lat": 1.2905022107620303,
    "lng": 103.84790615057861,
    "isOnline": false,
    "hosts": [
      "Brian Chew",
      "Zane Chee",
      "Sherry Jiang",
      "..."
    ],
    "organizerCalendar": "Codex Community Events",
    "organizerCalendarUrl": "https://lu.ma/codex-community",
    "ticketPriceMin": null,
    "ticketPriceMax": null,
    "currency": null,
    "isFree": true,
    "guestCount": 349,
    "coverImageUrl": "https://images.lumacdn.com/uploads/cj/a2636691-743f-4fa8-bc4e-43def51bbe3e.png",
    "description": "This is a community-organised event, not an official OpenAI event.\n\n🤖 Codex is OpenAI’s AI coding agent. You can describe what you want to build or change in everyday language, and Codex can help write code, fix bugs, and turn ideas into...",
    "source": "singapore",
    "sourceType": "city",
    "status": "ok",
    "error": null,
    "scrapedAt": "2026-11-20T02:50:31.814Z"
  },
  {
    "eventId": "evt-CNZg5fqDLOWqAgl",
    "name": "Designing Trust in the Digital Economy",
    "url": "https://lu.ma/xk2rbumg",
    "startAt": "2026-11-20T10:00:00.000Z",
    "endAt": "2026-11-20T13:00:00.000Z",
    "timezone": "Asia/Singapore",
    "city": "Singapore",
    "venueName": "MBFC Tower 3",
    "address": "MBFC Tower 3, 12 Marina Blvd, Singapore 018982",
    "lat": 1.2790221,
    "lng": 103.8544967,
    "isOnline": false,
    "hosts": [
      "Konrad Marzec",
      "OKX Events",
      "Sandy Khoo",
      "..."
    ],
    "organizerCalendar": null,
    "organizerCalendarUrl": null,
    "ticketPriceMin": null,
    "ticketPriceMax": null,
    "currency": null,
    "isFree": true,
    "guestCount": 146,
    "coverImageUrl": "https://images.lumacdn.com/uploads/sz/9afe8cc6-c63d-4f8c-9edb-70e68c5ce190.png",
    "description": "Introduction\n\nAs AI reshapes how we build, create, and transact, trust has become the currency that matters most. Join us for an event on using AI to build trust across the new money era, content, and AI itself with keynotes, and network...",
    "source": "singapore",
    "sourceType": "city",
    "status": "ok",
    "error": null,
    "scrapedAt": "2026-11-20T02:50:31.814Z"
  }
]
```

## How to run it

1. Choose your sources: searchQueries, cities, calendarUrls or eventUrls. They can be mixed in one run.
2. Set maxEvents, for example 20, which is a hard cap for the whole run.
3. Leave includeDetails on if you need descriptions and the real ticket tier range, or turn it off for one request per page.
4. Run the actor. Rows arrive with status ok, partial or error, and error rows cost nothing.
5. Export the dataset as JSON, CSV or Excel, or read it through the Apify API.

### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/subimpact~luma-events-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"cities":["singapore"],"maxEvents":50}'
```

### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("subimpact/luma-events-scraper").call(run_input={
      "cities": [
        "singapore"
      ],
      "maxEvents": 50
    })

for item in client.dataset(run["default_dataset_id"]).iterate_items():
    print(item)
```

### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('subimpact/luma-events-scraper').call({
  "cities": [
    "singapore"
  ],
  "maxEvents": 50
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(items);
```

### n8n

Use the Apify node (Run an Actor).
Actor ID: subimpact/luma-events-scraper
Input JSON: paste the example input below.

## Limits

- Public events only, with no private, unlisted or invite-only events.
- Hidden guest lists and hidden addresses stay null, and past events are not walked from city pages.
- isOnline false means not marked online, not proof of a physical venue.
- maxEvents caps a run at 2,000 events.

## FAQ

### What does an event cost?

Each delivered event costs $0.0015, which is $1.50 per 1,000 events, with the lowest tier at $1.00 per 1,000. There is no start fee, and platform usage is bundled into that price. Rows with status error, such as an unknown city slug or a deleted event URL, are free.

### Do I need a Luma account or API key?

No. The actor calls the same public JSON endpoints the Luma website uses, with no browser, login, cookies or key. That also means only public events: private events, unlisted events and invite links that need a session are not returned.

### Which cities can I scrape?

Any Luma discover city slug, which is the last part of the city page: singapore, kuala-lumpur, nyc, sf, berlin, zurich, frankfurt and the rest. A full https://lu.ma/singapore URL also works. An unknown slug produces one free error row naming the expected format.

### Why are some addresses and guest counts null?

Luma lets organisers hide the guest list and the exact address, and the address is often revealed only after RSVP. Those rows come back with guestCount null and venueName or address null, while coordinates are still filled where Luma exposes them.

### Can I get past events?

City and calendar sources return upcoming events only, because that is what Luma's pages serve. A past event URL given explicitly in eventUrls still returns its row, which is the way to fetch a specific historic event rather than walking backwards through a city.

### What does includeDetails change?

On by default, it makes one extra call per event to fill description, up to 8,000 characters of plain text, and the real minimum and maximum ticket prices across tiers. Turning it off spends one request per page instead of one per event, and description stays null.

### How are recurring events handled?

Each occurrence comes back as its own row with its own eventId and dates, so a weekly meetup appears once per date. Duplicates within a run are skipped, which matters when the same event is found by a keyword search and a calendar at once.

## Links

- Page: https://subimpact.net/apis/luma-events-scraper/
- Category: https://subimpact.net/apis/category/travel-events/
- Run on Apify: https://apify.com/subimpact/luma-events-scraper
- All data APIs: https://subimpact.net/apis/
- Catalogue JSON: https://subimpact.net/apis/catalogue.json
