# Luma Attendees Scraper (`martin.forejt/luma-attendees-scraper`) Actor

Scrapes the full attendee list from a lu.ma event. Returns one dataset row per attendee with name, headline, LinkedIn URL, Twitter, website, and event metadata. Requires a logged-in session cookie and event registration to access the complete guest list.

- **URL**: https://apify.com/martin.forejt/luma-attendees-scraper.md
- **Developed by:** [Martin Forejt](https://apify.com/martin.forejt) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Attendees Scraper

Extract the full attendee list from any [lu.ma](https://lu.ma) event — names, headlines, LinkedIn profiles, Twitter handles, and websites — ready for outreach, networking research, or enrichment pipelines.

Whether you're preparing for a conference, building a prospect list, or identifying who to meet at a meetup, this actor gives you structured, clean data for every registered guest.

### What you get

- **One dataset row per attendee** with contact and profile data
- **Event metadata** (name, date, location, topics, organizers) saved separately in the key-value store — no duplication across rows
- **LinkedIn URLs** as full, ready-to-use links (`https://www.linkedin.com/in/...`)
- **Organizers flagged** with `isOrganizer: true` so you can filter or prioritize them
- Works across **multiple events** in a single run

### Use cases

- **Event networking** — know who's attending before you walk in the door
- **Sales prospecting** — find decision-makers attending industry events
- **Recruiting** — identify talent at tech meetups and conferences
- **Market research** — understand who attends events in your space
- **Enrichment pipelines** — feed LinkedIn URLs directly into [LinkedIn Profile Enrichment](https://apify.com/anchor/linkedin-profile-enrichment)

### How it works

1. Opens the Luma event page using your session cookie
2. Extracts event metadata (name, date, location, topics, organizers)
3. Fetches the paginated attendee list via the Luma API (up to 5,000 guests)
4. Outputs one clean dataset row per attendee
5. Saves full event details to the key-value store under `event-{eventId}`

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `eventUrls` | string[] | Yes | One or more lu.ma event URLs, e.g. `https://lu.ma/my-event` |
| `lumaCookie` | string | Recommended | Session cookie from a logged-in lu.ma account. Required for the full guest list. |
| `scrapeGuests` | boolean | No (default: `true`) | Set to `false` to retrieve event metadata and organizers only, without the attendee list. |

### Getting your session cookie

The full guest list is only available to logged-in, registered attendees. To get your cookie:

1. Log into [lu.ma](https://lu.ma) in your browser
2. Open **DevTools** (`F12`) → **Application** → **Cookies** → `https://lu.ma`
3. Find the cookie named **`luma.auth-session-key`** and copy its value
4. Paste it into the `lumaCookie` field — it is stored as a secret and never logged

> **Tip:** You must also be **registered** (RSVP'd) for the event. Without registration, only the ~10 public featured guests are returned. Registering is usually one click on the event page.

### Output

#### Dataset — one row per attendee

| Field | Type | Description |
|---|---|---|
| `attendeeId` | string | Luma internal user ID |
| `name` | string | Full name |
| `headline` | string \| null | Job title or bio from their Luma profile |
| `linkedinUrl` | string \| null | Full LinkedIn URL, e.g. `https://www.linkedin.com/in/janesmith` |
| `twitterUrl` | string \| null | Full Twitter/X URL |
| `website` | string \| null | Personal or company website |
| `lumaUsername` | string \| null | Luma username slug |
| `lumaProfileUrl` | string \| null | Link to their Luma profile |
| `isOrganizer` | boolean | `true` if this person is a host or organizer |
| `eventId` | string | Foreign key — links to the event record in the key-value store |

#### Key-value store — event metadata

Full event details are stored once per event under the key `event-{eventId}`:

```json
{
  "id": "evt-xyz789",
  "name": "AI Founders Meetup",
  "url": "https://lu.ma/ai-founders",
  "description": "Monthly gathering of AI founders in San Francisco.",
  "startAt": "2026-08-01T18:00:00Z",
  "location": "San Francisco, CA",
  "topics": ["AI", "Startups"],
  "organizers": [{ "id": "usr-host1", "name": "Alice Chen", "linkedinUrl": "https://www.linkedin.com/in/alicechen" }],
  "coverage": {
    "guestCount": 312,
    "fetchedFullList": true
  }
}
````

#### Example dataset row

```json
{
  "attendeeId": "usr-abc123",
  "name": "Jane Smith",
  "headline": "AI Engineer at Acme Corp",
  "linkedinUrl": "https://www.linkedin.com/in/janesmith",
  "twitterUrl": "https://twitter.com/janesmith",
  "website": "https://janesmith.dev",
  "lumaUsername": "janesmith",
  "lumaProfileUrl": "https://lu.ma/user/janesmith",
  "isOrganizer": false,
  "eventId": "evt-xyz789"
}
```

### Integrations

**LinkedIn enrichment:** pipe `linkedinUrl` from the dataset into [LinkedIn Profile Enrichment](https://apify.com/anchor/linkedin-profile-enrichment) to get job history, company size, and seniority level for every attendee.

**AI ranking:** combine this actor's output with an LLM to score and rank attendees by relevance to your goals — e.g. filtering for investors, engineers in a specific domain, or people at companies you want to partner with.

### FAQ

**Do I need a Luma account?**
Yes — a free account is sufficient. You need to be logged in to get your session cookie, and registered for the event to access the full guest list.

**How many attendees can it fetch?**
Up to 5,000 per event. Most Luma events have well under 1,000 attendees.

**Are LinkedIn profiles scraped from LinkedIn?**
No. LinkedIn handles come from what attendees have entered on their own Luma profiles. For full LinkedIn data (job history, company, etc.) use [LinkedIn Profile Enrichment](https://apify.com/anchor/linkedin-profile-enrichment) as a follow-up step.

**What if the event is private or I'm not registered?**
The actor falls back to the ~10 publicly visible featured guests and flags `coverage.fetchedFullList: false` in the key-value store. Register for the event and re-run to get the full list.

**Can I scrape multiple events at once?**
Yes — pass multiple URLs in `eventUrls`. Each event gets its own key-value store record; all attendees land in the same dataset with their `eventId` as a reference.

# Actor input Schema

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

One or more lu.ma event URLs to scrape (e.g. https://lu.ma/my-event). Each URL produces one set of attendee rows in the dataset.

## `lumaCookie` (type: `string`):

Value of the luma.auth-session-key cookie from a logged-in lu.ma session. To get it: log into lu.ma → DevTools (F12) → Application → Cookies → https://lu.ma → copy the value of luma.auth-session-key. Without this, only the ~10 public featured guests are returned.

## `scrapeGuests` (type: `boolean`):

Fetch the attendee list. Disable to retrieve event metadata and organizers only.

## Actor input object example

```json
{
  "eventUrls": [
    "https://lu.ma/"
  ],
  "scrapeGuests": true
}
```

# Actor output Schema

## `attendees` (type: `string`):

One row per attendee with name, headline, LinkedIn URL, Twitter, website, and a foreign key (eventId) linking to the event record in the key-value store.

## `eventMetadata` (type: `string`):

Event name, description, location, topics, organizers, and coverage stats — stored once per event under the key event-{eventId}.

# 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 = {
    "eventUrls": [
        "https://lu.ma/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("martin.forejt/luma-attendees-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 = { "eventUrls": ["https://lu.ma/"] }

# Run the Actor and wait for it to finish
run = client.actor("martin.forejt/luma-attendees-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 '{
  "eventUrls": [
    "https://lu.ma/"
  ]
}' |
apify call martin.forejt/luma-attendees-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Luma Attendees Scraper",
        "description": "Scrapes the full attendee list from a lu.ma event. Returns one dataset row per attendee with name, headline, LinkedIn URL, Twitter, website, and event metadata. Requires a logged-in session cookie and event registration to access the complete guest list.",
        "version": "0.1",
        "x-build-id": "LRHXeQQEvMfWQVJyr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/martin.forejt~luma-attendees-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-martin.forejt-luma-attendees-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/martin.forejt~luma-attendees-scraper/runs": {
            "post": {
                "operationId": "runs-sync-martin.forejt-luma-attendees-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/martin.forejt~luma-attendees-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-martin.forejt-luma-attendees-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "eventUrls"
                ],
                "properties": {
                    "eventUrls": {
                        "title": "Event URLs",
                        "type": "array",
                        "description": "One or more lu.ma event URLs to scrape (e.g. https://lu.ma/my-event). Each URL produces one set of attendee rows in the dataset.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "lumaCookie": {
                        "title": "Luma session cookie",
                        "type": "string",
                        "description": "Value of the luma.auth-session-key cookie from a logged-in lu.ma session. To get it: log into lu.ma → DevTools (F12) → Application → Cookies → https://lu.ma → copy the value of luma.auth-session-key. Without this, only the ~10 public featured guests are returned."
                    },
                    "scrapeGuests": {
                        "title": "Scrape attendee list",
                        "type": "boolean",
                        "description": "Fetch the attendee list. Disable to retrieve event metadata and organizers only.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```