# Luma Events & Hosts Scraper (`khadinakbar/scrape-luma-events`) Actor

Scrape public Luma (lu.ma) events and hosts by event URL, city, calendar, search query, or host profile. HTTP-only via api.lu.ma, cookieless, no login. Honest public contract — no guest lists. MCP-ready.

- **URL**: https://apify.com/khadinakbar/scrape-luma-events.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, Social media, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 event scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

Scrape **public Luma (lu.ma / luma.com) events and hosts** into structured JSON for community ops, event marketing, and lead research. Feed city pages, calendars, event URLs, search keywords, or host profiles. The Actor uses cookieless HTTPS against Luma's public `api.lu.ma` — no login session, MCP-ready.

### What data can you extract from Luma?

| Field | Event row | Host row |
|---|---|---|
| Identity | `eventId`, `eventUrl`, `name` | `userId`, `username`, `profileUrl`, `name` |
| Timing | `startAt`, `endAt`, `timezone` | `joinedAt` |
| Place | venue + city/region/country + lat/lon when public | — |
| Tickets | `isFree`, `isSoldOut`, `spotsRemaining`, ticket tiers | — |
| People | nested `hosts[]`, optional featured guests | bio, socials, website |
| Calendar | calendar name/slug/url | `eventHostedCount`, `eventAttendedCount` |
| Provenance | `scrapedAt`, source mode | `scrapedAt` |

### Best fit

Use this Actor when you need public Luma event calendars for a city or calendar slug, structured host profiles with public social links, or keyword discover search for upcoming meetups and launches. It fits community managers mapping a weekend, growth teams researching public hosts, and AI agents that need Luma rows without a browser.

### Related next step

When the same workflow needs Eventbrite ticketed listings with venues and organizers, pair it with [Eventbrite Events Scraper](https://apify.com/khadinakbar/eventbrite-events-scraper). For Meetup keyword and location search with RSVP counts, use [Meetup Events Scraper](https://apify.com/khadinakbar/meetup-events-scraper).

### Workflow story

A San Francisco community ops lead wants this week's public tech meetups plus host contact surfaces. She sets `startUrls: ["https://lu.ma/sf"]`, `maxResults: 25`, and `includeEventDetails: true`. The Actor resolves the city discover page, paginates public events, fetches detail payloads (venue, ticket tiers, nested hosts), and writes one dataset row per unique event. She then re-runs with `scrapeHosts: true` on a shortlist of event URLs to land dedicated host-profile rows with LinkedIn/Twitter/website when Luma publishes them — ready for CRM enrichment.

### How it works

1. Classifies each input as event, city/place discover, calendar, category, host profile, or free-text search
2. Calls Luma's public `api.lu.ma` over HTTPS (Origin/Referer `https://luma.com`) with optional Apify proxy
3. Paginates discover and calendar feeds until `maxResults` or the cursor ends
4. Optionally deep-fetches event detail and dedicated host profiles
5. Deduplicates by `eventId` / `userId`, charges PPE, then writes validated rows plus `OUTPUT` / `RUN_SUMMARY`

### Input example

```json
{
  "startUrls": ["https://lu.ma/sf"],
  "maxResults": 5,
  "includeEventDetails": true,
  "scrapeHosts": false
}
```

Host-profile example:

```json
{
  "hostUsernames": ["merve"],
  "maxResults": 1
}
```

### Example output

```json
{
  "recordType": "event",
  "eventId": "evt-example",
  "eventUrl": "https://luma.com/example",
  "name": "Founder Fireside",
  "startAt": "2026-10-01T22:30:00.000Z",
  "timezone": "America/Los_Angeles",
  "venueCity": "San Francisco",
  "isFree": true,
  "hosts": [{ "username": "merve", "name": "Merve Isler" }],
  "scrapedAt": "2026-09-30T12:00:00.000Z"
}
```

You can download the dataset as JSON, CSV, Excel, or HTML.

### Pricing

This Actor uses **Pay per event** with **platform usage** passed through to the caller. Current event prices:

- `apify-actor-start`: $0.00005 per run
- `event-scraped` (primary): $0.005 per unique public event written
- `host-scraped`: $0.004 per unique public host profile written

For example, 20 detailed SF events cost about $0.10 in named events plus small platform usage. Duplicates and rows past `maxResults` are not charged. Treat the **live Pricing tab** on the Actor page as the current source of truth for event prices and platform usage before budgeting a production run.

### Outcomes

Every run writes `OUTPUT` and `RUN_SUMMARY` with one of:

`COMPLETE` | `PARTIAL` | `VALID_EMPTY` | `INVALID_INPUT` | `UPSTREAM_FAILED` | `CONFIG_ERROR`

- `VALID_EMPTY`: Luma responded, but the slug/host/search had no public rows
- `INVALID_INPUT`: empty inputs or reserved paths such as sign-in pages
- `UPSTREAM_FAILED`: Luma's public API did not return usable data and nothing was saved

### Modes (auto-detected)

| Input | Behavior |
|-------|----------|
| Event URL / `evt-…` | One detailed event row |
| City / place slug (`sf`, `nyc`) | Paginated discover events |
| Calendar URL / `cal-…` | Paginated calendar items |
| Search keywords | Discover search |
| Host URL / username | Host profile row |

### API example

```bash
curl "https://api.apify.com/v2/acts/khadinakbar~scrape-luma-events/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":["https://lu.ma/sf"],"maxResults":5,"includeEventDetails":true}'
```

### MCP / agent prompt card

> Use scrape-luma-events to fetch up to 10 public San Francisco Luma events with full details. Return eventUrl, name, startAt, venueCity, isFree, and nested hosts. Then read the dataset and summarize free events this week.

### Tips for best results

- Prefer city or calendar URLs for broad coverage; use event URLs when you already have a slug
- Keep `includeEventDetails: true` when you need ticket tiers and nested hosts; set it false for lean city crawls
- Enable `scrapeHosts: true` only when you want dedicated host-profile rows (extra `host-scraped` charges)
- Cap `maxResults` to match your budget; billing stops at the cap across events and hosts
- Public guest/attendee rosters are outside this Actor's scope — it returns public event metadata and host profiles that Luma exposes without sign-in

### FAQ

**How do I scrape a city?** Paste `https://lu.ma/sf` (or another place slug) into `startUrls` and set `maxResults`.

**Can I get host LinkedIn links?** Yes when the host publishes them on their public Luma profile — use a host URL/username or `scrapeHosts: true` after events.

**Do I need a Luma account?** No. The Actor reads public `api.lu.ma` endpoints only.

### Builder's note

I built this after mapping Luma's public `api.lu.ma` surface live: `/url` for kind resolution, paginated discover and calendar feeds, event detail with hosts and ticket info, and user profiles. Guest-list endpoints return HTTP 401 without sign-in, so the public contract stays events and hosts only. Billing is charge-then-push with dedupe by `eventId` / `userId` so city + search overlaps never double-bill.

### Legal / responsible use

This Actor collects publicly visible Luma event and host profile fields only. You remain responsible for complying with applicable terms and privacy laws. Luma is a trademark of its respective owner. This independent Actor is not affiliated with, associated with, or endorsed by Luma.

# Changelog

This Actor's version history is a separate document: https://apify.com/khadinakbar/scrape-luma-events/changelog.md

# Actor input Schema

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

Public Luma event, city, calendar, or host URLs/slugs to scrape. Examples: https://lu.ma/sf (city), https://lu.ma/marvelous (calendar), https://lu.ma/kevinhartz (event), https://lu.ma/user/merve (host). Also accepts bare slugs like sf or evt-… api ids. NOT a guest-list scrape — attendees require login and are out of contract.

## `searchQueries` (type: `array`):

Free-text Luma discover searches (e.g. AI, startup mixer). Returns matching public events. Leave empty if you only use startUrls. NOT a location — use a city slug in startUrls for place discover.

## `hostUsernames` (type: `array`):

Luma host usernames without the URL (e.g. merve). Each becomes a host-profile scrape billed as host-scraped. Equivalent to https://lu.ma/user/{username}.

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

Hard cap on total unique dataset rows (events + hosts) across all modes. Stops pagination and charging once reached. Defaults to 50. Prefill 5 keeps quality tests cheap. Raise for deep crawls (max 5000).

## `includeEventDetails` (type: `boolean`):

When true (default), fetch each event's detail payload (description, ticket tiers, hosts, calendar). When false, return lean list-card fields only — faster and cheaper on large city crawls.

## `scrapeHosts` (type: `boolean`):

When true, after each detailed event also fetch dedicated host-profile rows for listed hosts (extra host-scraped charges). Defaults to false. Direct host URLs/usernames always scrape hosts regardless of this flag.

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

Proxy for api.lu.ma. Apify datacenter (default) works for public endpoints; switch to RESIDENTIAL only if you hit 403/429. This is not a Luma login session.

## Actor input object example

```json
{
  "startUrls": [
    "https://lu.ma/sf",
    "https://lu.ma/user/merve"
  ],
  "searchQueries": [
    "AI",
    "hackathon"
  ],
  "hostUsernames": [
    "merve"
  ],
  "maxResults": 5,
  "includeEventDetails": true,
  "scrapeHosts": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Public Luma event and host rows.

## `output` (type: `string`):

Final outcome, itemsPushed, eventsScraped, hostsScraped, and chargedEventCounts.

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

Per-target outcomes, retries, and billing counters.

# 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 = {
    "startUrls": [
        "https://lu.ma/sf"
    ],
    "maxResults": 5,
    "includeEventDetails": true,
    "scrapeHosts": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/scrape-luma-events").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 = {
    "startUrls": ["https://lu.ma/sf"],
    "maxResults": 5,
    "includeEventDetails": True,
    "scrapeHosts": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/scrape-luma-events").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 '{
  "startUrls": [
    "https://lu.ma/sf"
  ],
  "maxResults": 5,
  "includeEventDetails": true,
  "scrapeHosts": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call khadinakbar/scrape-luma-events --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/scrape-luma-events"
        }
    }
}
```

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/3JyCkOcgh4tjUanzW/builds/8M8ShuNhTKpVSv0l6/openapi.json