# Luma Event Scraper - lu.ma Events & Host Leads (`logiover/luma-event-scraper`) Actor

Luma (lu.ma) event scraper and unofficial API alternative. Export events and host leads to CSV/JSON with no login or API key.

- **URL**: https://apify.com/logiover/luma-event-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 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 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 Scraper

Scrape Luma (lu.ma) events by city or category — date, venue, price, guest count and the host's website and socials. This Luma event scraper (also a lu.ma events extractor and event-host lead tool) reads the site's own public data, so you get every upcoming event with no login and no API key, and export it to CSV, JSON or Excel.

It is two tools in one: an **event dataset** for trend tracking, calendars and market maps, and an **event-host lead engine** — every event carries the organizer name, website and social handles, so one run becomes a targeted host outreach list.

### What you get

One clean row per Luma event, with these fields:

- **Event** — `id`, `name`, `url`, `startAt`, `endAt`, `timezone`, `eventType`, `locationType`, `isOnline`, `requiresApproval`, `isSoldOut`, `spotsRemaining`, `guestCount`, `ticketCount`, `coverImage`
- **Price** — `isFree`, `priceValue`, `priceCurrency`
- **Location & geo** — `venueName`, `venueAddress`, `city`, `region`, `country`, `countryCode`, `latitude`, `longitude` (or a clean online flag)
- **Host leads** — `hostName`, `hostUsername`, `hostUrl`, `hostWebsite`, `hostBio`, `hostIsVerified`, `hostTwitter`, `hostInstagram`, `hostLinkedin`, `hostYoutube`, `hostTiktok`, `allHosts`
- **Calendar / community** — `calendarName`, `calendarSlug`, `calendarUrl`, `calendarTwitter`, `calendarInstagram`, `calendarLinkedin`
- `sourceUrl`, `scrapedAt`

Export every row as **CSV, JSON or Excel** (also HTML / API) — into your CRM, spreadsheet, BI tool or warehouse.

### Use cases

- **Event-host lead gen** — build outreach lists of organizers and communities (website + socials) by city or niche — for sponsors, venues and sponsorship sales.
- **Event & market intelligence** — track which cities, communities and topics (AI, crypto, startups) are heating up week over week.
- **Aggregators & calendars** — power a curated city or topic event calendar or newsletter from a scheduled run.
- **Community & BD prospecting** — find active hosts and recurring meetups to partner, sponsor or speak at.
- **Research & ML** — feed dates, geo, guest counts and pricing into trend models and dashboards.

### How to use

1. Open a Luma city or discover page (e.g. [lu.ma/sf](https://lu.ma/sf)), copy the URL, and paste it into `searchUrls`.
2. Set `maxResults` (use `0` for no limit). City and place pages paginate through every upcoming event automatically.
3. Click **Start**. When the run finishes, open the **Output / Dataset** tab and export to CSV, JSON or Excel.

Single city:

```json
{
  "searchUrls": ["https://lu.ma/sf"],
  "maxResults": 200
}
````

Multiple cities in one run:

```json
{
  "searchUrls": [
    "https://lu.ma/sf",
    "https://lu.ma/nyc",
    "https://lu.ma/london"
  ],
  "maxResults": 2000
}
```

#### Input fields

| Field | What it does |
|---|---|
| `searchUrls` | Luma page URLs copied from the site — city pages (`lu.ma/sf`, `lu.ma/nyc`, `lu.ma/london`…), discover categories, or any public calendar/community page. City & place pages paginate the full upcoming set. |
| `maxResults` | Global cap across all URLs. `0` = no limit. |
| `maxResultsPerSearch` | Per-URL cap. `0` = no cap. |
| `useProxy` / `proxyConfiguration` | Apify Proxy — residential recommended (default). |
| `maxConcurrency` | How many Luma URLs to run in parallel. |

#### Example output

```json
{
  "id": "evt-8DRVhINH9LTM7T4",
  "name": "Where Design Begins: An Open Exhibition",
  "url": "https://lu.ma/nqkyxczb",
  "startAt": "2026-06-04T18:00:00.000Z",
  "endAt": "2026-06-11T21:00:00.000Z",
  "timezone": "America/Los_Angeles",
  "locationType": "offline",
  "isOnline": false,
  "venueAddress": "488 Bryant St, San Francisco, CA 94107, USA",
  "city": "San Francisco",
  "region": "California",
  "country": "United States",
  "countryCode": "US",
  "latitude": 37.7817006,
  "longitude": -122.3956533,
  "isFree": true,
  "priceValue": null,
  "priceCurrency": null,
  "guestCount": 266,
  "coverImage": "https://images.lumacdn.com/uploads/v3/....jpg",
  "hostName": "Vizcom",
  "hostWebsite": "https://vizcom.com/",
  "hostTwitter": "Vizcom_ai",
  "hostInstagram": "vizcom_",
  "hostLinkedin": "/company/vizcomhq",
  "hostYoutube": "vizcom_ai",
  "calendarName": "Vizcom",
  "scrapedAt": "2026-06-05T16:20:00.000Z"
}
```

### FAQ

#### Do I need a Luma account or API key?

No. The actor reads public lu.ma event data — no login, no token, no API key.

#### Which pages can I scrape?

Any public Luma page that lists events: city pages (`lu.ma/sf`, `lu.ma/nyc`, `lu.ma/london`, `lu.ma/paris`…), discover category pages, and public calendar/community pages. City and place pages paginate through the full set of upcoming events.

#### Does it get online (virtual) events too?

Yes. Each event has a `locationType` and an `isOnline` flag; in-person events also include the full venue address plus latitude and longitude.

#### Will every event have the host's website and socials?

Whenever the host exposes them publicly on Luma, yes — website, Twitter/X, Instagram, LinkedIn, YouTube and TikTok come through. Fields the host left blank are returned as `null`.

#### Is this a lu.ma unofficial API or Luma API alternative?

Effectively, yes. Luma has no public events API, so this actor works as an unofficial lu.ma API / Luma API alternative — it reads the site's own public event data and returns it as clean, structured rows.

#### How do I export Luma events to CSV or JSON?

Run the actor on any public lu.ma page, then open the Output / Dataset tab and export your Luma event data to CSV, JSON or Excel — ready for your spreadsheet, CRM or BI tool.

#### Can I scrape Luma events without login?

Yes. The actor scrapes lu.ma without login and without an API key, reading only public event and organizer data.

### Changelog

#### 2026-06-07

- Docs: added coverage for lu.ma unofficial API / Luma API alternative use, exporting Luma events to CSV/JSON, and scraping Luma without login.

# Actor input Schema

## `searchUrls` (type: `array`):

Luma page URLs copied straight from lu.ma. Use a city page (e.g. https://lu.ma/sf, https://lu.ma/nyc, https://lu.ma/london), a discover category, or any public calendar/community page. City & place pages paginate through every upcoming event. Add as many as you like.

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

Stop after this many events across all URLs. 0 = no limit (a busy city can have hundreds of upcoming events).

## `maxResultsPerSearch` (type: `integer`):

Cap events collected per individual Luma URL. 0 = no per-URL cap.

## `useProxy` (type: `boolean`):

Route requests through Apify Proxy. Residential is recommended and is the default.

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

Apify Proxy settings. Residential gives the highest success rate.

## `maxConcurrency` (type: `integer`):

How many Luma URLs to process in parallel.

## Actor input object example

```json
{
  "searchUrls": [
    "https://lu.ma/sf"
  ],
  "maxResults": 200,
  "maxResultsPerSearch": 0,
  "useProxy": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 3
}
```

# Actor output Schema

## `id` (type: `string`):

Event ID

## `name` (type: `string`):

Event name

## `url` (type: `string`):

Event URL

## `startAt` (type: `string`):

Start

## `endAt` (type: `string`):

End

## `timezone` (type: `string`):

Timezone

## `eventType` (type: `string`):

Event type

## `locationType` (type: `string`):

Location type

## `isOnline` (type: `string`):

Online

## `venueAddress` (type: `string`):

Venue address

## `venueName` (type: `string`):

Venue name

## `city` (type: `string`):

City

## `region` (type: `string`):

Region

## `country` (type: `string`):

Country

## `countryCode` (type: `string`):

Country code

## `latitude` (type: `string`):

Latitude

## `longitude` (type: `string`):

Longitude

## `isFree` (type: `string`):

Free

## `priceValue` (type: `string`):

Price

## `priceCurrency` (type: `string`):

Currency

## `requiresApproval` (type: `string`):

Requires approval

## `isSoldOut` (type: `string`):

Sold out

## `spotsRemaining` (type: `string`):

Spots remaining

## `guestCount` (type: `string`):

Guest count

## `ticketCount` (type: `string`):

Ticket count

## `coverImage` (type: `string`):

Cover image

## `hostName` (type: `string`):

Host name

## `hostUsername` (type: `string`):

Host username

## `hostUrl` (type: `string`):

Host URL

## `hostWebsite` (type: `string`):

Host website

## `hostBio` (type: `string`):

Host bio

## `hostIsVerified` (type: `string`):

Host verified

## `hostTwitter` (type: `string`):

Host Twitter

## `hostInstagram` (type: `string`):

Host Instagram

## `hostLinkedin` (type: `string`):

Host LinkedIn

## `hostYoutube` (type: `string`):

Host YouTube

## `hostTiktok` (type: `string`):

Host TikTok

## `allHosts` (type: `string`):

All hosts

## `calendarName` (type: `string`):

Calendar

## `calendarSlug` (type: `string`):

Calendar slug

## `calendarUrl` (type: `string`):

Calendar URL

## `calendarTwitter` (type: `string`):

Calendar Twitter

## `calendarInstagram` (type: `string`):

Calendar Instagram

## `calendarLinkedin` (type: `string`):

Calendar LinkedIn

## `sourceUrl` (type: `string`):

Source URL

## `scrapedAt` (type: `string`):

Scraped at

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Luma Event Scraper - lu.ma Events & Host Leads",
        "description": "Luma (lu.ma) event scraper and unofficial API alternative. Export events and host leads to CSV/JSON with no login or API key.",
        "version": "1.0",
        "x-build-id": "iHG9bmeVcPxLmK1w6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~luma-event-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-luma-event-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/logiover~luma-event-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-luma-event-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/logiover~luma-event-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-luma-event-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",
                "properties": {
                    "searchUrls": {
                        "title": "Luma URLs",
                        "type": "array",
                        "description": "Luma page URLs copied straight from lu.ma. Use a city page (e.g. https://lu.ma/sf, https://lu.ma/nyc, https://lu.ma/london), a discover category, or any public calendar/community page. City & place pages paginate through every upcoming event. Add as many as you like.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results (total)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many events across all URLs. 0 = no limit (a busy city can have hundreds of upcoming events).",
                        "default": 200
                    },
                    "maxResultsPerSearch": {
                        "title": "Max results per URL",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap events collected per individual Luma URL. 0 = no per-URL cap.",
                        "default": 0
                    },
                    "useProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify Proxy. Residential is recommended and is the default.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. Residential gives the highest success rate.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent URLs",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many Luma URLs to process in parallel.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```