# Luma Events Scraper — Event & Host Data (`aitorsm/luma-events`) Actor

Scrape events from luma.com — name, dates, venue, pricing, capacity, plus full organizer profile with Instagram, LinkedIn, TikTok, YouTube, and website handles included by default. Built for lead generation, outreach, sponsorship targeting, and event aggregation.

- **URL**: https://apify.com/aitorsm/luma-events.md
- **Developed by:** [Aitor Sanchez-Mansilla](https://apify.com/aitorsm) (community)
- **Categories:** Lead generation, Automation, Agents
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 117 total users, 16 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: No ratings yet

## Pricing

from $24.00 / 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/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 - Discover Events, Organizers, and Communities for Lead Generation, Outreach, and Market Intelligence

[![Luma Events status](https://apify.com/actor-badge?actor=aitorsm/luma-events)](https://apify.com/aitorsm/luma-events)

Get clean, structured **event data** — and a ready-to-use **event organizer list** — for tech, community, and founder events from [Luma](https://luma.com), the modern event-discovery platform used by founders, communities, and event organizers worldwide. This Actor returns detailed, structured information for every event, including:

- Event name, description, start/end times, and timezone
- Full venue address with coordinates
- Ticket pricing, availability, sold-out status, and remaining spots
- Live attendance signals (guest count, tickets sold, near-capacity flag)
- **Organizer profile with social handles included by default** — Instagram, LinkedIn, Twitter / X, TikTok, YouTube, website, and verified-account status
- Per-host social handles for events run by multiple people
- Geographic metadata for filtering by city, region, or country

With a **user-friendly visual input**, this tool is built for sales teams, recruiters, sponsorship platforms, and marketing agencies who need fast, reliable access to Luma's organizer ecosystem.

### Use Cases

#### 1. **Event Organizer List + Lead Generation**

Build an **event organizer list** for any city — the most active organizers behind tech and community events — and pull their full social-media presence and websites in one pass. Use the verification-status signal (`verified_at` is set on verified accounts, `null` otherwise), live traction (`ticket_count`, `guest_count`), and the presence of social handles to surface high-value prospects without manual lookup.

#### 2. **Outreach List Building**

Every result already includes the organizer's Instagram, LinkedIn, TikTok, YouTube, and website — ready to be loaded into your CRM or outreach tool. No follow-up enrichment step required.

#### 3. **Sponsorship Targeting**

Score organizers by realized revenue (`ticket_count` × `ticket_info.price`) and by audience traction (`guest_count`), then weight by verification status (`verified_at`) and the breadth of their social footprint to prioritize the most sponsorable accounts in your category and city.

#### 4. **Recruiting Hosts, Speakers, and Creators**

The `hosts` array on each event lists every person running it, with their personal Instagram, LinkedIn, Twitter, TikTok, and YouTube handles. Perfect for talent scouting, creator partnerships, or speaker booking.

#### 5. **Competitive and Market Intelligence**

Track how often competitors run events, what they charge, which venues they book, and whether they're selling out. Run the Actor on a schedule and diff the output over time to spot momentum shifts.

#### 6. **Event Aggregation for Local Newsletters and Apps**

Pull a clean, structured feed of upcoming events for a city or category and republish it on your "What's Happening in \[City]" newsletter, tourism board, hotel concierge, or coworking-space app.

#### 7. **Lead Enrichment for Existing Lists**

Already have a list of organizer names or slugs? Use the `organizer` search mode to pull every event they've run (past, future, or both) along with their full social and website profile — great for enriching outbound prospect lists.

#### 8. **Cross-Platform Organizer Database**

Combine Luma data with Eventbrite, Meetup, or other event-platform datasets to build a unified organizer database. The shared fields (name, social handles, website, city) make deduplication straightforward.

#### 9. **Tech & Community Event Discovery**

Use the `category` mode (`tech`, `ai`, `climate`, `crypto`, `food`, `arts`, `fitness`, `wellness`, `family`, `books`, `games`, `running`) to track emerging tech and community events, hot topics, and rising organizers in a vertical you care about.

> **Coming soon:** keyword search and date range filtering. [Drop me a line](mailto:business@aitorsm.com) if either would unblock a use case for you — it helps me prioritize.

### Cost

This Actor uses pay-per-event pricing with tiered rates:

- **No subscription** - $0.03 per event returned
- **Full description add-on** (optional) - $0.01 per event when `enrichEventDetails` is on (see below)

Apify's platform costs are included, so the total amount is totally predictable for you. Set a maximum cost per run and the Actor stops when it is reached: you are never charged beyond it, and a description is charged only for an event that has one.

#### Optional: full event descriptions (`enrichEventDetails`)

The standard event record doesn't include the event's full description text. Turn on **`enrichEventDetails`** and the Actor adds a plain-text **`description`** field to each event. It's **off by default**, billed **$0.01 per event** only when enabled.

Trade-off to know: descriptions are retrieved **one event at a time**, so runs take noticeably longer. Leave it off if you only need listing data; turn it on when you need the full body copy.

### Input

The input is designed around four search modes, picked via the **`searchType`** dropdown. Fill in only the field(s) your chosen mode needs.

```json
{
  "searchType": "city",
  "city": "London",
  "period": "future",
  "maxItems": 100
}
```

Note: `city` is a **single string** — one city per run (to cover several cities, start one run per city).

- **`searchType`** — pick one:
  - `city` — return every upcoming event in a city.
  - `cityAndCategory` — return events in a city filtered by category.
  - `category` — return events in a category, biased toward the runner's geographic location. Use `cityAndCategory` instead if you want a predictable geographic scope.
  - `organizer` — return every event from one organizer (past, future, or all).
- **`city`** — the Luma city slug as it appears in the URL (e.g. `barcelona` for `luma.com/barcelona`, `sf` for San Francisco, `nyc` for New York, `la` for Los Angeles, `dc` for Washington). The actor also accepts human-friendly variants like `"New York"`, `"san francisco"`, `"los angeles"`. See [luma.com/discover](https://luma.com/discover) for the full canonical list.
- **`category`** — one of: `tech`, `ai`, `climate`, `crypto`, `food`, `arts`, `fitness`, `wellness`, `family`, `books`, `games`, `running`. The old value `fooddrink` still works and means `food`.
- **`organizer`** — either the calendar slug from the URL (e.g. `innerflowstudio` from `luma.com/innerflowstudio`) or the calendar ID (`cal-Mu5whmr6zoIz1Yz`). Both work; the slug is more convenient if you copy-paste from a browser.
- **`period`** — for organizer mode only: `future` (default), `past`, or `all`. `all` returns the upcoming events first, then the past ones, each event once. Use `past` to backfill an organizer's full event history.
- **`maxItems`** — optional cap on how many events to return. Leave blank to fetch everything available. The run also stops when your maximum cost per run is reached, and you are never charged beyond it.
- **`enrichEventDetails`** — optional, off by default. When on, adds the full plain-text **`description`** to each event. Descriptions are retrieved one event at a time (slower) and is billed at **$0.01 per event**. See [Cost](#cost).

Feel free to reach out if you need more advanced filtering options!

### Output

The data is returned in **JSON format**, ideal for direct ingestion into analytics platforms, CRMs, dashboards, or downstream pipelines. Below is a real example of a single event entry from a Los Angeles search:

```json
{
  "api_id": "evt-TLZB1y7FGB8qFtm",
  "event": {
    "api_id": "evt-TLZB1y7FGB8qFtm",
    "calendar_api_id": "cal-Or0NdeYS6Dd43c4",
    "cover_url": "https://images.lumacdn.com/event-covers/ah/869cf83c-7037-4e0b-b917-40e308e860f6.png",
    "name": "The Dinner Table at Telefèric Barcelona (Brentwood)",
    "start_at": "2026-05-22T02:00:00.000Z",
    "end_at": "2026-05-22T05:00:00.000Z",
    "timezone": "America/Los_Angeles",
    "event_type": "independent",
    "location_type": "offline",
    "visibility": "public",
    "geo_address_info": {
      "city": "Los Angeles",
      "region": "California",
      "country": "United States",
      "country_code": "US",
      "sublocality": "Brentwood",
      "full_address": "Telefèric Barcelona Los Angeles, 11930 San Vicente Blvd, Los Angeles, CA 90049, USA",
      "short_address": "11930 San Vicente Blvd, Los Angeles"
    },
    "coordinate": { "longitude": -118.4712044, "latitude": 34.052285 }
  },
  "calendar": {
    "api_id": "cal-Or0NdeYS6Dd43c4",
    "name": "The Dinner Table Club",
    "slug": "thedinnertable_club",
    "description_short": "Dinner Parties With Strangers In Your City 🥂",
    "avatar_url": "https://images.lumacdn.com/calendars/p5/29867af3-0cb8-41c8-aef0-b1cdbc6c77e6",
    "website": "https://www.thedinnertable.club/",
    "instagram_handle": "thedinnertable_club",
    "linkedin_handle": "/company/the-dinner-table-club",
    "twitter_handle": null,
    "tiktok_handle": "thedinnertable_club",
    "youtube_handle": "TheDinnerTable_Club",
    "verified_at": "2023-08-05T05:54:47.835Z",
    "luma_plan": "plus",
    "location": {
      "city": "New York",
      "country": "United States",
      "country_code": "US",
      "timezone": "America/New_York"
    },
    "geo_city": "New York",
    "geo_country": "United States"
  },
  "hosts": [
    {
      "api_id": "usr-IND6JbMKj3oA1wV",
      "name": "The Dinner Table Club",
      "username": "thedinnertable",
      "website": "https://thedinnertable.club/",
      "instagram_handle": "thedinnertable_club",
      "linkedin_handle": "/in/the-dinner-table-club",
      "tiktok_handle": "thedinnertable_club",
      "youtube_handle": "TheDinnerTable_Club",
      "twitter_handle": null,
      "is_verified": false
    }
  ],
  "guest_count": 12,
  "ticket_count": 12,
  "ticket_info": {
    "price": { "cents": 9500, "currency": "usd", "is_flexible": false },
    "is_free": false,
    "is_sold_out": false,
    "spots_remaining": 8,
    "is_near_capacity": false,
    "require_approval": false
  },
  "registration_availability": "open"
}
```

#### Fields

- **Event name and description** — `event.name`, plus a short cover image and theme colors.
- **Dates and timezone** — `event.start_at` and `event.end_at` (ISO 8601 UTC) plus the local `event.timezone`.
- **Venue and geography** — full address, sublocality, country, and `coordinate` (latitude / longitude).
- **Organizer profile** — name, slug, avatar, description, **website**, **Instagram, LinkedIn, Twitter, TikTok, YouTube handles**, verified-account flag, location, and Luma plan tier.
- **Hosts** — each individual running the event, with their personal social handles.
- **Pricing and capacity** — price (in cents + currency), free flag, sold-out flag, **spots remaining**, near-capacity flag, and whether the event requires approval to attend.
- **Live attendance signals** — `guest_count`, `ticket_count` — useful for ranking events by traction.

#### Simplified Overview

A simplified view of this data will be shown directly in the **Apify console**, where you can see a table of key event details including organizer, date, location, and ticket info. A second view, **Venue & tickets**, lists the address, coordinates, price, capacity and registration status of each event in flat columns. Both views read the same rows: the full JSON stays unchanged.

```json
{
  "event.name": "The Dinner Table at Telefèric Barcelona (Brentwood)",
  "event.start_at": "2026-05-22T02:00:00.000Z",
  "event.geo_address_info.city_state": "Los Angeles, California",
  "calendar.name": "The Dinner Table Club",
  "calendar.instagram_handle": "thedinnertable_club",
  "calendar.website": "https://www.thedinnertable.club/",
  "ticket_info.price.cents": 9500,
  "ticket_info.is_sold_out": false,
  "ticket_count": 12,
  "spots_remaining": 8
}
```

***

### How to Use

1. **Pick a search mode**: choose `city`, `cityAndCategory`, `category`, or `organizer` from the **searchType** dropdown.
2. **Fill in the required field(s)**: e.g. `city: "barcelona"` for a city search, or `organizer: "innerflowstudio"` to pull every event from one organizer.
3. **Run the Actor**: start the run. Check the Overview and All Fields tabs to inspect results as they arrive.
4. **Export Data**: once the run is complete, export the dataset in JSON, CSV, Excel, or HTML — directly into your CRM, spreadsheet, dashboard, or pipeline.

***

Start collecting Luma events today by running this Actor on Apify.

### Real-time API for apps and AI agents

Besides normal runs, you can get events instantly from a web address, with no run to start and no dataset to download: a few seconds per request, up to 50 events per request, for one city (optionally one category) or one organizer. Useful for apps and AI assistants that need "what's on in Barcelona?" right away. Normal runs work exactly as before; use them for more events or for full event descriptions. Parameters and examples are on the API tab.

**Cost:** same as a normal run: you pay per event returned. Requests that return nothing add no event charges, and your maximum cost per run is always respected. Unlike normal runs, Apify bills the platform usage of real-time requests to you separately, as it does for every Actor used this way.

### FAQ

**What event data does this return?**
For every event you get the name, description, start/end times and timezone, full venue address with coordinates, ticket pricing and availability, and live attendance signals (guest count, tickets sold, near-capacity flag). Each event also carries the organizer's profile — website plus Instagram, LinkedIn, Twitter/X, TikTok, and YouTube handles — and per-host social handles for events run by multiple people.

**How do I build an event organizer list?**
Run a `city` search and each result already includes the organizer's website and social handles, so the output is itself an **event organizer list** ready to load into a CRM — no follow-up enrichment step. Use the `organizer` mode to pull a single organizer's full event history (past, future, or all) for deeper enrichment.

**What kinds of events is Luma best for?**
Luma skews toward tech, AI, startup, founder, and community events, plus arts, wellness, food & drink, and fitness meetups. The `category` mode lets you slice by `tech`, `ai`, `climate`, `crypto`, `food`, `arts`, `fitness`, `wellness`, `family`, `books`, `games`, or `running`.

**Which cities are supported?**
Any Luma city slug (e.g. `barcelona`, `sf`, `nyc`, `la`, `dc`); the Actor also accepts human-friendly names like "New York" or "Los Angeles". See [luma.com/discover](https://luma.com/discover) for the full list.

**Can I run it on a schedule?**
Yes. Schedule the Actor and diff the output over time to track how often organizers run events, what they charge, and whether they're selling out. It also runs through Apify's integrations for downstream pipelines.

**Why use this Actor?**
This Actor returns the full structured record per event — organizer socials, pricing, and live attendance signals included — with no API key, no auth, and no quota to manage.

### Related Actors

- [Email Extractor](https://apify.com/aitorsm/email-extractor) — turn the host websites from your results into emails and phone numbers.
- [Eventbrite Events Extractor](https://apify.com/aitorsm/eventbrite) — add the ticketed events in the same city, with organizer details, to widen your list.
- [Meetup Events](https://apify.com/aitorsm/meetup-events) — add the tech and community meetups in the same city that are not on Luma.
- [Meetup Groups](https://apify.com/aitorsm/meetup-groups) — find the recurring tech communities in the same city and the named organizers who run them.

**Related reading:** [The contact-enrichment cascade — what order to fire your tools in](https://www.linkedin.com/pulse/contact-enrichment-cascade-what-order-fire-your-tools-aitor-165ae/) — how to turn the organizer websites this Actor surfaces into emails and phones, cheapest-first (with real hit rates per step).

### Contact

- **Email**: <business@aitorsm.com> — for custom features, advanced filtering, tailored data products, or anything off-spec.
- **Apify Discord**: find me as `aitor.sm`.

If this actor has been useful to you, please consider adding it to your bookmarks 📑 on Apify.

# Actor input Schema

## `searchType` (type: `string`):

Pick how you want to discover events.

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

ONE city per run, as a single string (not a list/array). Pick from the dropdown — or type any Luma city yourself: a name ("San Francisco", "Barcelona", "Tokyo") or its Luma URL slug ("sf", "nyc", "la") both work. Required when searchType is "city" or "cityAndCategory". To cover several cities, start one run per city.

## `category` (type: `string`):

Luma category slug, e.g. 'tech', 'ai' or 'food'. Required when searchType is 'category' or 'cityAndCategory'. 'fooddrink' is the old name of 'food' and still works.

## `organizer` (type: `string`):

Either the calendar slug from the URL (e.g. 'innerflowstudio' from luma.com/innerflowstudio) OR the calendar ID (e.g. 'cal-Mu5whmr6zoIz1Yz'). Required when searchType is 'organizer'.

## `period` (type: `string`):

Organizer mode only: 'future' = upcoming events, 'past' = past events, 'all' = upcoming events first, then past ones (each event once).

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

Maximum number of events (rows) to return. Leave blank to fetch all available. Your maximum cost per run also stops the run when it is reached.

## `enrichEventDetails` (type: `boolean`):

Add the full plain-text `description` to each event. Retrieved one event at a time (slower) and is billed separately per event. Leave off for listing data only.

## Actor input object example

```json
{
  "searchType": "city",
  "city": "barcelona",
  "period": "future",
  "maxItems": 20,
  "enrichEventDetails": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `venueTickets` (type: `string`):

No description

# 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 = {
    "city": "barcelona",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("aitorsm/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 = {
    "city": "barcelona",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("aitorsm/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 '{
  "city": "barcelona",
  "maxItems": 20
}' |
apify call aitorsm/luma-events --silent --output-dataset

```

## MCP server setup

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