# Luma Events Scraper | lu.ma Events, Hosts & Tickets API (`data_daemon/luma-events-scraper`) Actor

$1.50 per 1,000 events, description + hosts included | Scrape Luma (lu.ma) events by city, category, keyword or calendar: dates, venue, GPS, ticket prices, guest counts, host profiles. Only-new mode for daily schedules. JSON API, no login, no proxy.

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

## Pricing

Pay per event

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 | lu.ma Events, Hosts, Tickets & Calendars API

**Turn Luma (lu.ma / luma.com) into a clean, scheduled event feed.** Luma is where tech meetups, AI hackathons, founder dinners, run clubs and conference side events get published first: **87 discover cities** (San Francisco, New York, London, Berlin, Bengaluru, Tokyo, Singapore ...) and **12 categories** with about **18,000 upcoming events** between them (AI 3,783, Tech 4,187, Arts & Culture 3,441, counted 19 Oct 2026). This Actor reads Luma's own JSON API and returns one row per event with **start and end time (UTC, local and timezone), venue and full address with GPS, in-person or online, free or paid with price range and currency, sold-out and spots-remaining flags, guest count, the organiser calendar with website and social handles, every host's public profile (name, bio, profile URL, website, LinkedIn, X, Instagram), Luma categories, cover image, full description (text + HTML) and all public ticket types**.

**$1.50 per 1,000 events, description, hosts and ticket types included**, plus $0.001 per run. No login, cookies, proxy or browser. Built for schedules: switch on **Only new events since the last run** and a daily run returns, and charges for, only the events you have not received before. Events you already have can also be passed in `skipEventIds`.

> Live check, 19 Oct 2026, on the Apify platform: San Francisco listed **105** upcoming events; three cities (San Francisco, New York, London) gave **100 events with full details in 36 seconds** for $0.15 plus the $0.001 start fee. The default run (the 25 soonest San Francisco events with details) takes about 10 seconds and costs **$0.04**.

### Who uses Luma data, and what for

| You are | What this Actor gives you |
|---|---|
| **Sponsorship, developer-relations and field-marketing teams** | Every upcoming AI, crypto or tech event in your target cities with guest counts, hosts and organiser calendars, so you know which meetups to sponsor, speak at or send a team to. |
| **B2B sales and lead generation** | Hosts and organiser calendars are companies and community leaders with their website and LinkedIn / X / Instagram handles on the event page: a weekly list of who is running events in your market. |
| **Event aggregators, newsletters and city guides** | A JSON feed of Luma events by city or category with stable ids (`dedupKey`), local times, venues with coordinates, prices and cover images, de-duplicated across cities and runs. |
| **Founders, investors and community managers** | Track what the ecosystem is doing this week: founder dinners, demo days, hackathons, workshops; follow specific calendars (`lu.ma/<organiser>`) and get new events the morning they are published. |
| **Researchers and analysts** | Event volume by city, category, price and format over time; which organisers are most active; how fast events sell out. |
| **AI agents (MCP)** | Ask Claude or ChatGPT "free AI meetups in London this week" and let it call this Actor through Apify's MCP server. |

### Quick start (about a minute)

1. Click **Try for free**. The form is pre-filled with `San Francisco`.
2. Optionally add cities (`New York`, `London`, `Bengaluru`), categories (`ai`, `tech`, `crypto`), a keyword (`hackathon`), a date window (**Days ahead** = `7`) or paste an organiser calendar URL such as `https://lu.ma/planetscale`.
3. Click **Start**. 25 events with full details take about 10 seconds and cost **$0.04**.
4. Download the results as JSON, CSV or Excel, or save the input as a task, tick **Only new events since the last run** and **schedule it daily** to get a fresh feed in Google Sheets, a webhook, Make, Zapier or n8n.

**From code** (returns the events in one call):

```bash
curl -X POST "https://api.apify.com/v2/acts/data_daemon~luma-events-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"cities": ["London"], "categories": ["ai"], "daysAhead": 7, "maxEvents": 100}'
```

**From an AI assistant:** add the MCP connector `https://mcp.apify.com/?tools=data_daemon/luma-events-scraper` in Claude, ChatGPT, Cursor or VS Code.

### Input

```json
{
    "cities": ["San Francisco", "New York"],
    "categories": ["ai"],
    "query": "hackathon",
    "startUrls": ["https://lu.ma/planetscale"],
    "daysAhead": 14,
    "priceType": "free",
    "eventFormat": "any",
    "includeDetails": true,
    "maxEvents": 100
}
```

| Field | Type | Description |
| --- | --- | --- |
| `cities` | array | Luma discover cities: `San Francisco`, `New York`, `London`, `Berlin`, `Amsterdam`, `Paris`, `Bengaluru`, `Mumbai`, `Singapore`, `Tokyo`, `Sydney`, `Toronto`, `Mexico City`, `Dubai`, `Lagos` and 72 more (any `lu.ma/<city>` page). Common alternatives are mapped (`NYC`, `Bangalore`, `Bombay`, `SF`, `LA`, `DC`, `Hong Kong`, `Delhi`). One upcoming-events feed per city, soonest first. `city`, `location` and `locations` are accepted as aliases. Set to `[]` to search worldwide with a keyword. |
| `categories` | array | Optional. `ai`, `tech`, `arts`, `climate`, `crypto`, `fitness`, `wellness`, `running`, `books`, `games`, `family`, `fooddrink` (names like `Arts & Culture` or `Food & Drink` work too). Luma lists category events by location, so each category is scraped around each city. |
| `query` | string | Optional keyword, searched by Luma in names and descriptions inside each city, category or calendar feed (Luma returns up to 50 matches per feed). The Actor keeps only hits that actually contain one of your words, because Luma's search is fuzzy. `keywords`, `search` and `q` are accepted as aliases. |
| `startUrls` | array | Optional lu.ma / luma.com links or ids: organiser calendars (`https://lu.ma/planetscale`, `cal-...`), single events (`https://lu.ma/qjw9i5a9`, `evt-...`), cities (`https://lu.ma/sf`) or categories (`https://lu.ma/ai`). When only URLs are given, the default city is not scraped. `calendarUrls` and `eventUrls` are accepted as aliases. |
| `daysAhead` | integer | Only events starting within the next N days (1-365). Feeds are ordered by start date and stop at the window's end, so a 7-day window is fast and cheap. |
| `startDateFrom` / `startDateTo` | string | Explicit window, `YYYY-MM-DD` or ISO date-time (UTC). `startDateFrom` is applied by Luma's own date cursor, so later pages are never fetched for nothing. |
| `priceType` | string | `any` (default), `free` or `paid`. `onlyFree: true` is accepted as an alias. |
| `eventFormat` | string | `any` (default), `in-person` (has a physical venue) or `online` (no venue, a meeting link as venue, or location not announced). City and category feeds list in-person events; online events come from calendar URLs and keyword searches with an empty city list. |
| `includeDetails` | boolean | Fetch each event's page (default `true`, one extra request per new event, same price): full description as text and HTML, every public ticket type with price and capacity, Luma categories, sold-out flag. Off = feed fields only, about twice as fast. |
| `maxEvents` | integer | Stop after this many saved events (default 25). |
| `maxEventsPerSource` | integer | Optional cap per city / category / calendar feed (0 = none), so one busy city does not use up `maxEvents`. |
| `onlyNewSinceLastRun` | boolean | Deliver only events that an earlier run with the same `stateKey` has not delivered; skipped events are not charged (default `false`). |
| `stateKey` | string | Name of this saved search's memory for `onlyNewSinceLastRun`. Derived from the cities, categories, keyword and URLs when empty. Use a new key to start over. |
| `skipEventIds` | array | Event `id`s (`evt-...`) or `lu.ma/<slug>` URLs you already have. Skipped before any detail fetch and never charged. Large lists are fine. |
| `proxyConfiguration` | object | Optional (Advanced). Luma's JSON API answers Apify's datacenter IPs directly, so none is needed. |

Bad input never fails the run: unknown fields are ignored with a warning, numbers and booleans may be sent as strings, a reversed date window is swapped, an unknown city or a keyword with no matches ends with `Saved 0 events` and an explanation in the status message, and `{}` scrapes the default city.

### Output

One record per event. Example from a real run on 19 Oct 2026 (description shortened):

```json
{
    "id": "evt-Dgnnl0IoUmK5Se1",
    "dedupKey": "luma:evt-Dgnnl0IoUmK5Se1",
    "url": "https://lu.ma/qjw9i5a9",
    "name": "PlanetScale Movie Night: You Can See Everything",
    "startAt": "2026-10-18T00:30:00.000Z",
    "endAt": "2026-10-18T05:30:00.000Z",
    "timezone": "America/Los_Angeles",
    "startAtLocal": "2026-10-17T17:30:00-07:00",
    "endAtLocal": "2026-10-17T22:30:00-07:00",
    "format": "in-person",
    "venue": "AMC Kabuki 8",
    "address": "AMC Kabuki 8, 1881 Post St, San Francisco, CA 94115, USA",
    "city": "San Francisco",
    "region": "California",
    "country": "United States",
    "countryCode": "US",
    "lat": 37.7849354,
    "lng": -122.4325232,
    "addressHidden": false,
    "isFree": true,
    "price": 0,
    "maxPrice": null,
    "currency": null,
    "soldOut": false,
    "spotsRemaining": 3,
    "nearCapacity": true,
    "requireApproval": true,
    "registration": "open",
    "waitlist": true,
    "guestCount": 0,
    "eventType": "independent",
    "seriesId": null,
    "visibility": "public",
    "discoverCity": "San Francisco",
    "calendar": {
        "id": "cal-5vct8djci1YNWY3",
        "name": "PlanetScale",
        "slug": "planetscale",
        "url": "https://lu.ma/planetscale",
        "description": null,
        "avatarUrl": "https://images.lumacdn.com/uploads/we/48d47801-3975-4805-a0a7-3b6a998c0870.png",
        "website": "https://planetscale.com",
        "isVerified": false,
        "isPersonal": false,
        "twitter": "planetscale",
        "instagram": "planetscale",
        "linkedin": "/company/planetscale",
        "youtube": "planetscale",
        "tiktok": "planetscale",
        "city": "San Francisco",
        "country": "United States"
    },
    "hosts": [
        {
            "id": "usr-fTgO1tTlScvZImG",
            "name": "PlanetScale",
            "bio": "The fastest MySQL and Postgres in the cloud.",
            "username": "planetscale",
            "profileUrl": "https://lu.ma/user/planetscale",
            "avatarUrl": "https://images.lumacdn.com/avatars/9i/3c3e5d91-3678-4033-8ac2-aec2807f2153.png",
            "website": "https://planetscale.com",
            "linkedin": "/company/planetscale",
            "twitter": "planetscale",
            "instagram": null,
            "tiktok": null,
            "youtube": "PlanetScale",
            "isVerified": false
        },
        {
            "id": "usr-AxQcBZZ4CCJf061",
            "name": "Sam Lambert",
            "bio": null,
            "username": "samlambert",
            "profileUrl": "https://lu.ma/user/samlambert",
            "avatarUrl": "https://images.lumacdn.com/avatars/aj/a0582378-525a-40bd-a77a-e769f1394326.jpg",
            "website": null,
            "linkedin": "/in/isamlambert",
            "twitter": "samlambert",
            "instagram": null,
            "tiktok": null,
            "youtube": null,
            "isVerified": false
        }
    ],
    "hostNames": ["PlanetScale", "Sam Lambert", "Christian Glassiognon"],
    "categories": ["Arts & Culture"],
    "coverUrl": "https://images.lumacdn.com/uploads/mz/2609393e-5edb-465f-9332-b682c62032a7.png",
    "description": "Nathan Fielder made a documentary about Elizabeth Holmes, we got a bunch of tickets to watch it with you.\n\nJoin us at AMC Kabuki 8 to watch You Can See Everything (https://a24films.com/films/you-can-see-everything)…",
    "descriptionHtml": "<p>Nathan Fielder made a documentary about Elizabeth Holmes, we got a bunch of tickets to watch it with you.</p>\n<p>Join us at AMC Kabuki 8 to watch <a href=\"https://a24films.com/films/you-can-see-everything\"><em>You Can See Everything</em></a>…</p>",
    "ticketTypes": [
        {
            "id": "ttype-EHfmkHRsAiH7SWz",
            "name": "Standard",
            "isFree": true,
            "price": 0,
            "currency": null,
            "description": null,
            "capacity": null,
            "spotsRemaining": null,
            "requireApproval": true,
            "validFrom": null,
            "validUntil": null
        }
    ],
    "source": { "type": "city", "name": "San Francisco" },
    "scrapedAt": "2026-10-19T04:18:09.449Z"
}
```

| Field | Notes |
| --- | --- |
| `id`, `dedupKey`, `url` | Luma event id, a stable `luma:<id>` key for your own de-duplication, and the public event page (`https://lu.ma/<slug>`). |
| `name`, `coverUrl`, `eventType`, `seriesId`, `visibility` | Title, cover image, `independent` or part of a series (`seriesId`), always `public`. |
| `startAt`, `endAt`, `timezone`, `startAtLocal`, `endAtLocal` | UTC ISO timestamps, the event's IANA timezone and the same times written in that zone (`2026-10-17T17:30:00-07:00`), ready for calendars and "this evening" filters. |
| `format` | `in-person` (physical venue) or `online` (no venue, a meeting link as the venue, or location not announced). |
| `venue`, `address`, `city`, `region`, `country`, `countryCode`, `lat`, `lng`, `addressHidden` | Venue name and full address with coordinates as shown on the event page. When the host shows the address only to registered guests, Luma shows the neighbourhood: the Actor keeps `venue` and `address` `null`, rounds the coordinates to about 1 km and sets `addressHidden: true` (45 of the 100 events in the live check). City, region and country are always present for in-person events. |
| `isFree`, `price`, `maxPrice`, `currency` | Free flag and the cheapest / most expensive public ticket in the event's currency (`27` + `USD`), `null` for free events. |
| `soldOut`, `spotsRemaining`, `nearCapacity`, `requireApproval`, `registration`, `waitlist` | Capacity and registration state (`registration` is Luma's `open` / closed value; `requireApproval` = host approves each guest; `waitlist` = waitlist active). |
| `guestCount` | Number of guests going, as the host shows it publicly (0 when the host hides the count). |
| `discoverCity` | The Luma discover city the event is featured in (`San Francisco`), also for events in nearby towns. |
| `calendar.*` | The organiser calendar: `id`, `name`, `slug`, page `url`, short description, avatar, website, verified flag, `isPersonal`, X / Instagram / LinkedIn / YouTube / TikTok handles, home city and country. |
| `hosts[]`, `hostNames` | Every host shown on the event page: `id`, `name`, `bio`, `username`, public `profileUrl` (`https://lu.ma/user/<username>`), avatar, website, LinkedIn / X / Instagram / TikTok / YouTube handles, verified flag. `hostNames` is a flat list for CSV and Sheets. |
| `categories` | The event's Luma categories (`AI`, `Tech`, `Arts & Culture` ...), with `includeDetails`. |
| `description`, `descriptionHtml` | Full description as plain text (links kept in brackets) and simple HTML, with `includeDetails`; `null` when the host wrote none. |
| `ticketTypes[]` | Every public ticket type with `name`, `isFree`, `price`, `currency`, `description`, `capacity`, `spotsRemaining`, `requireApproval`, `validFrom`, `validUntil`, with `includeDetails`. Hidden ticket types are left out. |
| `source`, `scrapedAt` | Which city, category, calendar, keyword search or URL produced the row, and the collection time. |

No attendee data is collected: guest lists, guest names, e-mails and phone numbers are never requested or output, even where Luma's pages show "N going" avatars. Download as JSON, CSV, Excel, or push to Google Sheets, webhooks and other Apify integrations. Field names are stable; new fields are only added, so your Sheets, Zapier or Make mappings keep working.

### Scheduling & automation

The heavy users of this Actor run it on a schedule with a short city list, a category or keyword, a 7-14 day window, and let the Actor remember what it has already delivered.

**Recipe: AI and tech events in three cities, next 14 days, only new events, every morning**

```json
{
    "cities": ["San Francisco", "New York", "London"],
    "categories": ["ai", "tech"],
    "daysAhead": 14,
    "onlyNewSinceLastRun": true,
    "stateKey": "ai-tech-3-cities-daily",
    "maxEvents": 500
}
```

1. Paste the input, click **Save as task**, then **Schedules → Create schedule → Daily** (for example `0 8 * * *`) and add the task.
2. The first run delivers every matching event in the window. Every later run delivers only the events that were not delivered before, and **skipped events are not charged**. The memory lives in a key-value store named `luma-events-state` in your own Apify account, one record per `stateKey`, and forgets ids after 120 days.
3. Give each saved search its own `stateKey` (or leave it empty and the Actor derives one from the cities, categories, keyword and URLs). Change the key to start over.
4. Already de-duplicating on your side? Pass the `id`s you have in `skipEventIds` instead; they are skipped before any detail fetch and never charged.

**Follow organisers instead of cities:** put calendar URLs in `startUrls` (`https://lu.ma/planetscale`, `https://lu.ma/design`) with `onlyNewSinceLastRun: true` and the run returns each organiser's newly published events.

**Where the results go**

- **Integrations tab of the task**: Google Sheets (append rows), Slack or email (a message per run), or a **webhook** to your backend when the run finishes.
- **Make, Zapier, n8n**: use the Apify module/node with the task id, or poll the dataset with the API call below.
- **Every run writes a `RUN-SUMMARY` record** to its key-value store: sources scraped, events found, new, filtered, skipped (already delivered / `skipEventIds`) and charged counts, so a webhook consumer can decide what to do without opening the dataset.

**Synchronous API call** (waits for the run and returns the new events):

```bash
curl -X POST "https://api.apify.com/v2/acts/data_daemon~luma-events-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls": ["https://lu.ma/planetscale"], "onlyNewSinceLastRun": true, "stateKey": "planetscale-daily"}'
```

### Pricing and what a month costs

Pay per event. Platform compute is included; the Actor runs in 256 MB, so the start fee is always a single event.

| Event | Price | When it is charged |
|---|---|---|
| Event | $0.0015 | Each event saved to your dataset, details (description, ticket types, hosts) included |
| Actor start | $0.001 | Once per run |

That is **$1.50 per 1,000 events**. Events skipped by **Only new events since the last run**, `skipEventIds`, de-duplication across feeds or your date, price and format filters are never charged.

**Plan discounts:** prices above are for the Free and Starter plans; Scale plans pay 15% less ($1.28 per 1,000) and Business plans 30% less ($1.05 per 1,000).

| How teams use it | Volume (measured 19 Oct 2026) | Cost |
|---|---|---|
| Quick look: the 25 soonest San Francisco events with details | 25 events, 1 run | $0.039 |
| Three cities, everything upcoming, 100 events | 100 events, 1 run, 36 s | $0.15 |
| One organiser calendar, all upcoming events | 4 events, 1 run | $0.007 |
| Daily feed, only new events: AI + Tech in 3 cities, 14-day window | about 20-40 new events a day, 30 runs | about $1-2 a month |
| Weekly export: every upcoming event in 10 cities | about 800 events, 4 runs | about $5 a month |

Apify's free plan includes $5 of usage a month: about 3,300 events with details, enough for a trial and several small daily feeds.

### Tips

- Use `daysAhead` (7 or 14) with schedules: feeds are date-sorted and stop at the window's end, so runs stay small and fast.
- Categories multiply with cities (2 categories × 3 cities = 6 feeds). Events found in several feeds are saved and charged once.
- Keyword searches return Luma's 50 best matches per feed; combine a keyword with a city or category for precision, or set `cities: []` for a worldwide top-50.
- `includeDetails: false` when you only need names, dates, venues, prices and hosts; it halves the run time.
- Set a **maximum cost per run** on the task; the Actor stops cleanly at the limit and says so in the status message.

### FAQ

**How much does it cost to scrape Luma?**

$0.0015 per event with its full details plus $0.001 per run, so 100 events cost about $0.15 and a daily feed of 20 new events about $1 a month.

**Is there an official Luma API?**

Luma has a paid API for calendar owners (their own events). This Actor reads the public JSON that the lu.ma website itself loads for discover, category, calendar and event pages, and exposes it as a REST API with schedules, webhooks and only-new runs. No login or API key is needed.

**Does it collect attendees or guest lists?**

No. The Actor never requests or outputs guest lists, guest names, e-mails or phone numbers, including the "N going" avatars shown on event pages. It outputs the hosts' and organiser calendar's public profile information exactly as the event page shows it (name, bio, profile URL, website and social handles).

**Why is the address missing on some events?**

Hosts can show the exact address only to registered guests. Luma then shows the city and neighbourhood, and so does the Actor: `address` and `venue` are `null`, `addressHidden` is `true`, and the coordinates are rounded to about 1 km. City, region and country are still filled in.

**Why does an online-only run of a city return nothing?**

Luma's city and category pages list events with a physical location near that city. Online events are found through organiser calendars (`startUrls`) and keyword searches with `cities: []`, and are marked `format: "online"`.

**Which cities and categories exist?**

The 87 cities on lu.ma/discover (any `lu.ma/<city>` page; the Actor also resolves new cities live) and the 12 categories `ai`, `tech`, `arts`, `climate`, `crypto`, `fitness`, `wellness`, `running`, `books`, `games`, `family`, `fooddrink`. A city or category Luma does not know ends the run with `Saved 0 events` and the known examples in the status message.

**Can I scrape past events?**

Not in this version: Luma's public feeds list upcoming events. Open an issue if you need an organiser's past events.

**Does it work for luma.com links?**

Yes. lu.ma and luma.com are the same site; paste either form in `startUrls`.

**Do I need a proxy or login?**

No.

### Related Actors by Daemon Data

- [Foundit Jobs Scraper](https://apify.com/data_daemon/foundit-jobs-scraper) – foundit.in (Monster India) jobs with full descriptions, salary bands and only-new mode
- [IIMJobs Jobs Scraper](https://apify.com/data_daemon/iimjobs-jobs-scraper) – India's MBA, finance, consulting and management jobs with full descriptions and only-new mode
- [Hirist.tech Jobs Scraper](https://apify.com/data_daemon/hirist-jobs-scraper) – India IT and tech jobs with full descriptions, same scheduling conventions as this Actor
- [Oracle Jobs Scraper](https://apify.com/data_daemon/oracle-hcm-jobs-scraper) – every job on any Oracle Recruiting Cloud (Oracle HCM) career site
- [India IPO Tracker](https://apify.com/data_daemon/india-ipo-tracker) – live IPO GMP, subscription and listing data for India
- [Tickertape India Stocks Scraper](https://apify.com/data_daemon/tickertape-stocks-scraper) – NSE/BSE fundamentals, shareholding and screener
- [Dubai Property Transactions](https://apify.com/data_daemon/dubai-property-transactions) – Dubai Land Department sales, mortgages and gifts
- [UK Gazette Insolvency Notices](https://apify.com/data_daemon/uk-gazette-insolvency-notices) – winding-up petitions, administrations and liquidations

### Support

Found a bug or need another field, filter or source (past events, a specific calendar type)? Open an issue on the Issues tab; issues are usually answered within a day. Custom variants of this Actor are available on request.

A quick review on the actor page helps other users find it.

### Disclaimer

This Actor collects publicly available event listings for informational purposes and deliberately leaves out attendee data. Respect Luma's terms of use and applicable data-protection laws when using the data, in particular when contacting hosts.

# Actor input Schema

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

Luma discover cities, e.g. `San Francisco`, `New York`, `London`, `Berlin`, `Bengaluru`, `Tokyo`, `Singapore` (87 cities; a `lu.ma/<city>` URL or a `discplace-...` id works too). One upcoming-events feed per city, newest start date last. An event found in two feeds is saved and charged once. Leave one city for a quick first run; set the list empty to search worldwide with a keyword.

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

Optional. Luma categories: `ai`, `tech`, `arts`, `climate`, `crypto`, `fitness`, `wellness`, `running`, `books`, `games`, `family`, `fooddrink`. Each category is scraped around each city above (Luma lists category events by location). Several categories = any of them.

## `query` (type: `string`):

Optional keyword searched by Luma in event names and descriptions, e.g. `hackathon`, `founders`, `yoga`, `web3`. Applied inside each city, category and calendar feed (Luma returns the 50 best matches per feed). With `cities` set to an empty list and no other source, it searches worldwide.

## `startUrls` (type: `array`):

Optional. Any public lu.ma / luma.com link: an organiser calendar (`https://lu.ma/planetscale`), a single event (`https://lu.ma/qjw9i5a9`), a city (`https://lu.ma/sf`) or a category (`https://lu.ma/ai`); `cal-...`, `evt-...`, `discplace-...` ids too. Calendars return their upcoming events. When only URLs are given, the default city is not scraped.

## `daysAhead` (type: `integer`):

Only events starting within the next N days (1-365), e.g. `7` for this week's events. Leave empty for all upcoming events (feeds are ordered by start date, so `maxEvents` takes the soonest ones).

## `startDateFrom` (type: `string`):

Optional earliest start date, `YYYY-MM-DD` or ISO date-time (UTC), e.g. `2026-11-01`. Applied by Luma's own date cursor, so later pages are not fetched for nothing.

## `startDateTo` (type: `string`):

Optional latest start date, `YYYY-MM-DD` (inclusive) or ISO date-time. Each feed stops at the first event after this date.

## `priceType` (type: `string`):

`any` (default), `free` (ticket price 0 / no ticket) or `paid` (at least one paid ticket type). Checked on every event before it is saved or charged.

## `eventFormat` (type: `string`):

`any` (default), `in-person` (events with a physical venue) or `online` (no venue or a meeting link as the venue, incl. events whose location is not announced).

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

On (default): one extra request per new event adds the full description (plain text and HTML), every public ticket type with its price, the event's Luma categories and the sold-out flag. The price per event is the same either way. Off: feed fields only (name, dates, venue, GPS, price range, hosts, calendar, guest count), roughly twice as fast.

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

Stop after this many saved events (default 25). Cost: $0.0015 per event with details, so 25 events = $0.04. A city has 50-150 upcoming events; raise this for full exports.

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

Optional cap per feed so one busy city does not use up `maxEvents` (0 = no cap).

## `onlyNewSinceLastRun` (type: `boolean`):

On: deliver only events that an earlier run with the same `stateKey` has not already delivered, and skip the rest without charging. Off (default): return every matching event.

## `stateKey` (type: `string`):

Optional name for this search's memory when `onlyNewSinceLastRun` is on, e.g. `sf-ai-daily`. Leave empty to derive it from the cities, categories, keyword and URLs. Use a new key to start over.

## `skipEventIds` (type: `array`):

Event ids you already have (the `id` field from earlier runs, e.g. `evt-Dgnnl0IoUmK5Se1`; `lu.ma/<slug>` URLs are accepted too). Skipped before any detail fetch and never charged. Large lists are fine.

## `proxyConfiguration` (type: `object`):

Optional, none by default. Luma's public JSON API answers Apify's datacenter IPs directly, so no proxy is needed; set one only if your own network policy requires it.

## Actor input object example

```json
{
  "cities": [
    "San Francisco"
  ],
  "categories": [],
  "startUrls": [],
  "priceType": "any",
  "eventFormat": "any",
  "includeDetails": true,
  "maxEvents": 25,
  "maxEventsPerSource": 0,
  "onlyNewSinceLastRun": false,
  "skipEventIds": []
}
```

# Actor output Schema

## `dataset` (type: `string`):

Events as JSON items in the default dataset (also downloadable as CSV, Excel, XML).

## `runSummary` (type: `string`):

RUN-SUMMARY record: sources scraped, events found, new, filtered, skipped (already delivered / skipEventIds) 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"
    ],
    "categories": [],
    "startUrls": [],
    "skipEventIds": []
};

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

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

```

## MCP server setup

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