# Luma Events Scraper – lu.ma Events, Hosts & Tickets by City (`openharvest/luma-events-scraper`) Actor

Luma events scraper for public lu.ma / luma.com events by city, category, keyword, calendar or event URL. Get dates, venues, geo coordinates, hosts, guest counts, ticket prices and sold-out status. No login.

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

## Pricing

$1.50 / 1,000 event scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 by City

Luma events scraper for public lu.ma / luma.com events by city, category, keyword, calendar or event URL. Get dates, venues, geo coordinates, hosts, guest counts, ticket prices and sold-out status. No login.

The Actor reads the same public JSON endpoints that the luma.com website uses. It needs no browser and no login. For San Francisco it returns about 1,300 upcoming events, not only the ~70 curated picks on luma.com/sf.

**Price: $1.50 per 1,000 events.** Duplicates are not charged.

### What can this Luma scraper do?

- **Events by city** – any city in the world. Luma's 80+ featured cities (San Francisco, New York, London, Berlin, Paris, Singapore, Tokyo...) are matched directly; any other city name is geocoded automatically.
- **Events by category** – AI, Tech, Crypto, Arts & Culture, Climate, Fitness, Wellness, Food & Drink, Books, Games, Running, Family – combined with any city.
- **Keyword search** – e.g. "hackathon", "startup", "yoga" in each city.
- **Calendars / communities** – paste a calendar URL such as `https://luma.com/deepmind` to get all its upcoming or past events (including external events listed on the calendar).
- **Single events** – paste any `luma.com/...` or `lu.ma/...` event link.
- **Tickets & pricing** – free / paid, price range, currency, pay-what-you-want, sold out, spots remaining, approval required, waitlist.
- **Hosts** – host names and public Luma profile links.
- **Full details (optional)** – plain-text description, every ticket type, categories.
- **De-duplication** across all sources, and a run summary in the key-value store.

### Use cases

- **Event discovery & newsletters** – build "what's on this week in Berlin" digests or AI-event calendars.
- **Lead generation & partnerships** – find active community organizers, venues and sponsors in your niche.
- **Market research** – track how many AI / crypto / climate events happen per city and how fast they sell out.
- **Sales & DevRel** – find meetups and hackathons where your audience is.
- **Data journalism & academic research** on tech-community activity.
- **Travel & hospitality apps** – enrich city guides with live event listings.

### How to use

1. Click **Try for free**.
2. Enter one or more **Cities** (e.g. `San Francisco`, `London`) and optionally **Categories** (`ai`, `tech`) or a **Search keyword**.
3. Or paste **Luma URLs** – events, calendars (`https://luma.com/deepmind`), city pages (`https://luma.com/nyc`) or category pages (`https://luma.com/ai`).
4. Set **Max events** and click **Start**. Download results as JSON, CSV, Excel, XML or HTML, or use the API.

### Input

| Field | Description |
|---|---|
| `cities` | City names. Featured Luma cities are matched by name or slug (`sf`, `nyc`, `la`, `dc`...). Other cities are geocoded. |
| `categories` | `ai`, `tech`, `crypto`, `arts`, `climate`, `fitness`, `wellness`, `food`, `books`, `games`, `running`, `family`. Combined with each city (San Francisco if no city is given). |
| `searchQuery` | Optional keyword search within each city (Luma returns up to ~50 best matches per city). |
| `startUrls` | Luma event, calendar, city or category URLs (`luma.com` or `lu.ma`). |
| `calendarPeriod` | `future` (default) or `past` – for calendar URLs. |
| `onlyFeatured` | `false` (default) = all public events around each city. `true` = only Luma's curated city-page list. |
| `includeDetails` | Adds description, all ticket types, categories and the full host list. Same price. |
| `maxItems` | Total limit (default 30, `0` = unlimited). |
| `maxItemsPerSource` | Optional cap per city / category / calendar when you scrape several. |
| `proxyConfiguration` | Usually not needed. |

Example input:

```json
{
    "cities": ["San Francisco", "New York"],
    "categories": ["ai"],
    "includeDetails": true,
    "maxItems": 200,
    "maxItemsPerSource": 100
}
```

### Output

Each event is one dataset row. Real example (London, `includeDetails: true`, description shortened):

```json
{
    "eventId": "evt-tdEhLNJoWCJFCV9",
    "url": "https://luma.com/AIonDraughtAICrisisResponse",
    "name": "AI on Draught: AI Crisis Response",
    "startAt": "2026-10-08T17:00:00.000Z",
    "endAt": "2026-10-08T19:30:00.000Z",
    "timezone": "Europe/London",
    "city": "London",
    "region": "England",
    "country": "United Kingdom",
    "countryCode": "GB",
    "venueName": "London AI Hub",
    "address": "London AI Hub, 140 Goswell Rd., London EC1V 7DY, UK",
    "addressVisibility": "public",
    "latitude": 51.524930499999996,
    "longitude": -0.0992686,
    "locationType": "offline",
    "isOnline": false,
    "coverUrl": "https://images.lumacdn.com/uploads/sd/ece97507-a4a9-4417-8548-0de3744971d4.png",
    "hosts": [
        { "name": "London AI Hub", "username": "londonaihub", "profileUrl": "https://luma.com/user/londonaihub" }
    ],
    "hostNames": "London AI Hub",
    "guestCount": 46,
    "isFree": true,
    "price": 0,
    "maxPrice": null,
    "currency": null,
    "priceText": "Free",
    "isSoldOut": false,
    "spotsRemaining": 274,
    "isNearCapacity": false,
    "requiresApproval": true,
    "registrationStatus": "open",
    "waitlistActive": false,
    "calendarName": "London AI Hub",
    "calendarId": "cal-CJ9PBT5AyF0qRIH",
    "calendarUrl": "https://luma.com/londonaihub",
    "featuredCity": null,
    "platform": "luma",
    "source": "London / \"AI\"",
    "scrapedAt": "2026-10-07T18:15:26.341Z",
    "description": "We are bringing together a curated group of 30 leaders, founders, and innovators shaping how organisations prepare for, and respond to, AI systems going wrong –...",
    "categories": ["AI"],
    "ticketTypes": [
        { "name": "Standard", "type": "free", "price": 0, "currency": null, "isFlexible": false, "requiresApproval": true, "spotsRemaining": null }
    ]
}
```

Notes on fields:

- `startAt` / `endAt` are UTC (ISO 8601); `timezone` is the event's local time zone.
- `venueName`, `address`, `latitude`, `longitude` are only filled when the organizer made the address public. If the address is shown to registered guests only, `addressVisibility` is `guests-only` and only the city/region is returned.
- `guestCount` is `null` when the organizer hides the guest list (with `includeDetails` the registered-ticket count is used when available).
- `platform: "external"` marks events that a calendar lists from another site (e.g. Partiful); `url` then points to that site.
- `description`, `categories`, `ticketTypes`, `socialImageUrl` are added only with `includeDetails: true`.

The Output tab has ready-made views: **Events**, **Location & geo**, **Tickets & pricing** and **Hosts & calendars**. A run summary (events per source, stop reason) is saved as `SUMMARY` in the key-value store.

### Pricing

Pay-per-event. You only pay for events saved to the dataset. Platform usage is included.

| Event | Price | When it is charged |
|---|---|---|
| `event` | **$0.0015** per event ($1.50 / 1,000) | Each event saved to the dataset |
| Duplicates | **Free** | The same event found through several cities, categories or calendars |

`includeDetails` costs the same.

| Job | Cost |
|---|---|
| 30 events (default run) | **$0.045** |
| 1,000 events | **$1.50** |
| 10,000 events | **$15.00** |

Set **Max cost per run** in the run options. The Actor stops cleanly when it reaches your budget.

### Use with AI agents (MCP)

The Actor works as a tool in the [Apify MCP server](https://mcp.apify.com), so Claude, ChatGPT, Cursor and other MCP clients can call it. Example tool input for "What AI events are on in London this week?":

```json
{
    "cities": ["London"],
    "categories": ["ai"],
    "maxItems": 20
}
```

The agent reads `name`, `startAt`, `timezone`, `venueName`, `priceText`, `isSoldOut` and `url` from each row.

### FAQ

**How many events can I get for a city?**
All public upcoming events Luma lists around that city. For big tech hubs that is often 1,000+ (San Francisco ≈ 1,300 at the time of writing). Turn on `onlyFeatured` if you only want Luma's curated picks.

**Can I scrape past events?**
Yes, for calendars: add the calendar URL and set `calendarPeriod` to `past`. City/category discovery only covers upcoming events (that is what Luma shows).

**Why are some addresses empty?**
Many organizers show the exact address only to approved guests. We respect that and return only what is public.

**Does it return attendee lists or emails?**
No. The Actor returns only public event information and public host profile links – no emails, phone numbers or guest identities.

**My city is not in Luma's list – will it work?**
Yes. Any city name is geocoded and Luma is searched by coordinates around it.

**Do I need a proxy or login?**
No. Luma's public endpoints work without login. Enable Apify Proxy only if you ever see rate limiting.

**Can I schedule it?**
Yes – use Apify Schedules (e.g. every morning) and integrations (Google Sheets, Slack, Zapier, Make, webhooks) to get fresh events automatically.

### Is it legal to scrape Luma?

This Actor only collects **publicly available event information** that anyone can see on luma.com without logging in, and it does not collect personal data such as emails or guest lists. Host names and profile links are included only as they appear publicly. You are responsible for using the data in line with Luma's terms, GDPR and other applicable laws – especially if you plan to contact hosts. If unsure, consult a lawyer.

### Related actors

Other actors by the same developer:

- **Eventbrite Scraper – Events, Tickets & Organizers by City** – add Eventbrite events for the same cities
- **Google Sheets Import & Export – Read, Append & Dedupe Rows** – keep a running event list in a sheet
- **Hacker News Scraper – Stories, Comments & Who Is Hiring Jobs** – follow what the tech community is talking about

### Support & feedback

Found a bug or need a field that is missing? Open an issue in the **Issues** tab.

# Actor input Schema

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

City names, e.g. "San Francisco", "New York", "London", "Berlin". Luma's featured cities (80+) are matched directly; any other city is geocoded and searched by coordinates.

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

Luma discovery categories. Combined with each city (or San Francisco if no city is given). Known values: ai, tech, crypto, arts, climate, fitness, wellness, food, books, games, running, family.

## `searchQuery` (type: `string`):

Optional keyword search within each city (e.g. "startup", "hackathon", "yoga"). Luma returns at most ~50 best matches per city for a keyword search.

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

Paste any public Luma links: single events (https://luma.com/abc123), calendars / communities (https://luma.com/deepmind), city pages (https://luma.com/nyc) or category pages (https://luma.com/ai). lu.ma links work too.

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

For calendar URLs: scrape upcoming or past events.

## `onlyFeatured` (type: `boolean`):

Off (recommended): return ALL public events in and around each city (e.g. 1,000+ for San Francisco). On: only the short curated list shown on Luma's city page (luma.com/sf).

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

Fetch each event's detail page to add the full description, all ticket types with prices, categories and the complete host list. Slightly slower, same price.

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

Maximum number of events to return in total (0 = no limit). You are only charged for events actually returned.

## `maxItemsPerSource` (type: `integer`):

Optional cap per source so that one big city does not use up the whole Max events budget when you scrape several cities or categories (0 = no per-source cap).

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

Luma's public API usually works without a proxy. Enable Apify Proxy if you see blocking or rate limits.

## Actor input object example

```json
{
  "cities": [
    "San Francisco"
  ],
  "categories": [
    "ai",
    "tech"
  ],
  "startUrls": [
    {
      "url": "https://luma.com/deepmind"
    }
  ],
  "calendarPeriod": "future",
  "onlyFeatured": false,
  "includeDetails": false,
  "maxItems": 30,
  "maxItemsPerSource": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All scraped items in the default dataset (JSON, CSV, Excel and more via the dataset export).

## `files` (type: `string`):

Records saved in the default key-value store, e.g. the run summary.

# 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": 30,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("openharvest/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": 30,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("openharvest/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": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call openharvest/luma-events-scraper --silent --output-dataset

```

## MCP server setup

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