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

Reliable lu.ma events scraper — dates, venue, price, capacity, and host social profiles by city, category, keyword, calendar, or URL. Built for event lead generation.

- **URL**: https://apify.com/surk/luma-events-scraper.md
- **Developed by:** [Roee Tsur](https://apify.com/surk) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 3 total users, 2 monthly users, 82.4% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 event results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Luma Events Scraper

Scrape public events from **Luma (lu.ma / luma.com)** into clean, structured rows — event name,
dates, timezone, venue, city, price, capacity, cover image, and the host with their social
profiles. Point it at a city, a category, a search keyword, a community calendar, or specific event
URLs and get back one row per event. Built as a fast, reliable **lu.ma events API** alternative for
**event lead generation**, **event sponsorship leads**, market research, and event aggregation.

### What does Luma Events Scraper do?

- Discovers events five ways — `citySlugs` (e.g. `sf`, `nyc`, `london`), `categorySlugs`
  (`tech`, `ai`, `food`, `crypto`, …), `searchKeywords`, `calendarUrls`, and `eventUrls`.
- Returns one dataset row per event with `name`, `url`, `startAt`, `endAt`, `timezone`, `venue`,
  `city`, `isOnline`, `price`, `capacity`, `coverImageUrl`, `hostName` and `hostUrl`.
- Includes the host's public socials — `instagram`, `linkedin`, `twitter`, `tiktok`, `youtube`,
  `website` — **for free on every event** when the host lists them.
- Filters by date with `dateWindow` (next 7/14/30/90 days or all upcoming), or exact
  `startsAfter` / `startsBefore` bounds, and caps the run with `maxEvents`.
- Optionally enriches each host (`enrichHosts`) with their full profile: authoritative socials plus
  `hostBio`, `hostIsVerified`, and `hostEventsHostedCount`.

Honest limits: lu.ma hides exact street addresses on approval-gated events, so `venue` and
`capacity` are `null` when the host does not publish them, and attendee lists are never collected.

### Why use Luma Events Scraper for event lead generation?

Every event is a warm lead list of organizers and sponsors. This actor turns lu.ma into a
structured feed you can push straight into a CRM, outreach tool, or spreadsheet — with host social
handles attached — so you can find and qualify **event sponsorship leads** and creator/organizer
contacts at scale. Like every Apify actor, you can run it on a schedule, call it from the Apify API,
or wire it into Make, Zapier, and MCP for AI agents.

### How to use Luma Events Scraper

1. Open the actor and click **Try for free**.
2. Add at least one source — for example `citySlugs: ["sf"]` — then set `dateWindow`, `maxEvents`,
   and toggle `enrichHosts` if you want deep host profiles.
3. Click **Start**.
4. Download results from the **Output** tab (JSON, CSV, Excel) or via API.

### How much does Luma Events Scraper cost?

Transparent pay-per-event pricing — you pay only for results, with **no start fee**:

| Event           | Price            | When it is charged                                             |
| --------------- | ---------------- | -------------------------------------------------------------- |
| `result-item`   | $0.002 per event | Once per event stored in the dataset.                          |
| `host-enriched` | $0.007 per host  | Only when `enrichHosts` is on — once per unique host profiled. |

Worked example: 1,000 events with `enrichHosts` off costs about **$2.00**. The same 1,000 events
with `enrichHosts` on and ~600 unique hosts costs about **$2.00 + $4.20 = $6.20**. This undercuts the
feature-rich lu.ma scrapers on the Store (which charge roughly $0.0025–$0.005 per event, several with
extra per-run start fees), while returning host socials on the base tier.

### Input example

```json
{
  "citySlugs": ["sf", "nyc"],
  "categorySlugs": ["ai"],
  "searchKeywords": ["founders dinner"],
  "calendarUrls": [],
  "eventUrls": [],
  "dateWindow": "next-30-days",
  "maxEvents": 200,
  "enrichHosts": true
}
```

### Output example

One dataset item (fields match the **Output** tab and the dataset schema exactly):

```json
{
  "name": "Cafe Cursor San Francisco: Startup Edition",
  "url": "https://lu.ma/cafe-cursor-sf-startups",
  "startAt": "2026-07-20T17:00:00.000Z",
  "endAt": "2026-07-21T01:00:00.000Z",
  "timezone": "America/Los_Angeles",
  "venue": "123 Market St, San Francisco, CA",
  "city": "San Francisco",
  "isOnline": false,
  "price": "Free",
  "capacity": 80,
  "coverImageUrl": "https://images.lumacdn.com/uploads/01/540ce980-5529-4bcd-94d9-87f950c877e4.png",
  "hostName": "Sarah Goomar",
  "hostUrl": "https://lu.ma/user/sarahgoomar",
  "instagram": null,
  "linkedin": "https://linkedin.com/in/sarahgoomar",
  "twitter": null,
  "tiktok": null,
  "youtube": null,
  "website": "https://example.com",
  "hostBio": "Organizer of startup meetups in SF.",
  "hostIsVerified": true,
  "hostEventsHostedCount": 42
}
```

`hostBio`, `hostIsVerified`, and `hostEventsHostedCount` are populated only when `enrichHosts` is
enabled.

### FAQ

**Is it legal to use Luma Events Scraper?**
It extracts only publicly available event data from lu.ma without logging in, and never collects
attendee lists or private data. You are responsible for how you use the data in your jurisdiction.

**Do I need a proxy?**
No. lu.ma serves these public pages reliably without a proxy at normal volumes. For very large or
bursty runs you can supply an optional `proxyConfiguration`.

**How does host enrichment get charged?**
When `enrichHosts` is on, the actor fetches each host's full profile once and charges one
`host-enriched` event per **unique** host — repeated hosts in the same run are never double-charged.
Host name, profile URL, and any socials already on the event are always included for free.

**Can I run it on a schedule or from my own code?**
Yes — schedule runs in Apify Console or start them via the Apify API and integrations (Make, Zapier,
MCP for AI agents).

**Something broke or you need a feature?**
Open an issue on the actor's **Issues** tab — issues are typically answered within a few days.

# Actor input Schema

## `citySlugs` (type: `array`):

lu.ma discover place slugs to scrape, e.g. "sf", "nyc", "la", "london", "tel-aviv". Note: San Francisco's slug is "sf" (not "san-francisco"). Find slugs in the URL of any lu.ma city page, e.g. lu.ma/sf.

## `categorySlugs` (type: `array`):

lu.ma discover category slugs to scrape. One of: tech, food, ai, arts, climate, fitness, wellness, crypto.

## `searchKeywords` (type: `array`):

Free-text keywords to search lu.ma events, e.g. "music", "founders dinner". Each keyword is searched across the discover feed.

## `calendarUrls` (type: `array`):

Full lu.ma calendar/community URLs, e.g. https://lu.ma/designbuildship. All upcoming events on each calendar are scraped.

## `eventUrls` (type: `array`):

Full lu.ma event URLs to scrape directly, e.g. https://lu.ma/abc123.

## `dateWindow` (type: `string`):

Only include events starting within this window from the run time. Ignored for a source when startsAfter/startsBefore are set.

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

Stop after this many events have been stored. Each stored event is charged as one result-item.

## `enrichHosts` (type: `boolean`):

Fetch each event host's full lu.ma profile to add authoritative socials plus host bio, verified status and events-hosted count. Adds one host-enriched charge per unique host. Host name, profile URL and any socials already on the event are always included for free, even when this is off.

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

Advanced: only include events starting at or after this ISO 8601 date/time (overrides Date window as the lower bound). Example: 2026-08-01.

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

Advanced: only include events starting at or before this ISO 8601 date/time (overrides Date window as the upper bound). Example: 2026-09-01.

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

Advanced: optional Apify proxy. Not required for normal use; enable a datacenter proxy for large or bursty runs.

## Actor input object example

```json
{
  "citySlugs": [
    "sf"
  ],
  "dateWindow": "next-7-days",
  "maxEvents": 10
}
```

# Actor output Schema

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

Scraped lu.ma events, one item per event. See the dataset schema for per-field descriptions.

# 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 = {
    "citySlugs": [
        "sf"
    ],
    "dateWindow": "next-7-days",
    "maxEvents": 10,
    "enrichHosts": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("surk/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 = {
    "citySlugs": ["sf"],
    "dateWindow": "next-7-days",
    "maxEvents": 10,
    "enrichHosts": False,
}

# Run the Actor and wait for it to finish
run = client.actor("surk/luma-events-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "citySlugs": [
    "sf"
  ],
  "dateWindow": "next-7-days",
  "maxEvents": 10,
  "enrichHosts": false
}' |
apify call surk/luma-events-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=surk/luma-events-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/vjJk2AezuISvejYz2/builds/fqJAYe9MfzRYMgmZ4/openapi.json