Luma Events Scraper

Scrape public Luma events, calendars, hosts, dates, locations, prices, and registration status for event intelligence workflows.

Data fields

FieldTypeDescription
eventUrlstringValue exported as eventUrl.
eventIdstring | nullValue exported as eventId.
eventTitlestring | nullValue exported as eventTitle.
eventDescriptionstring | nullValue exported as eventDescription.
startDatestring | nullValue exported as startDate.
endDatestring | nullValue exported as endDate.
timezonestring | nullValue exported as timezone.
locationNamestring | nullValue exported as locationName.

Input preview

startUrlsLuma URLs
queryTopic / category query
locationLocation
dateFromStart date from
dateToStart date to
maxItemsMaximum events

API and agents

This actor can be run through Apify API, datasets, webhooks, schedules, and the official Apify MCP server.

How this actor works

See example inputs, outputs, API usage, and practical limits before running this actor on Apify.

Open Apify page

Extract public event data from Luma pages, calendars, places, and topic listings.

Use it to monitor upcoming events, discover community calendars, enrich lead lists, and build local event feeds from publicly visible Luma information.

What does Luma Events Scraper do?

Luma Events Scraper collects public event records from Luma.

It can start from public event pages, city/place pages, calendar pages, topic pages, and discovery-style pages.

Each saved row represents one public Luma event.

The actor returns event URLs, titles, dates, time zones, public location details, organizer calendar information, public hosts, images, prices, registration status, and scrape metadata.

It does not collect private attendees, RSVP answers, hidden registration data, or information that requires logging in.

Who is it for?

Event marketers use it to track communities that overlap with their audience.

Community managers use it to monitor comparable meetups and calendars.

Startup and VC teams use it to discover founder, AI, tech, climate, and ecosystem events.

Sales teams use it to find sponsorship, partnership, and field-marketing opportunities.

Local event aggregators use it to create city calendars and newsletters.

Researchers use it to map public event density by topic, city, host, or calendar.

Why use this actor?

✅ Scrape public Luma event data without building your own parser.

✅ Use city, topic, calendar, discover, or individual event URLs.

✅ Export clean rows to JSON, CSV, Excel, XML, RSS, or API integrations.

✅ Keep runs small for monitoring or scale up for larger event discovery workflows.

✅ Avoid private attendee data and focus on public event metadata.

What data can you extract?

Field Description
eventUrl Public Luma event URL
eventId Luma event API ID when available
eventTitle Event name
eventDescription Public event description when available
startDate Event start date/time in ISO format
endDate Event end date/time in ISO format
timezone Event timezone
locationName Public city/place name
address Public or obfuscated address text visible on Luma
isOnline Whether the event is online
hostNames Public host names when visible
hostUrls Public host links when visible
calendarName Luma calendar / organizer name
calendarUrl Public calendar URL
imageUrl Event image URL
tags Public categories/tags when available
priceText Free/paid price text
registrationStatus Registration availability or sold-out status
sourceUrl URL that produced the row
scrapedAt Timestamp of extraction

How to scrape Luma events

  1. Open the actor on Apify.

  2. Add one or more public Luma URLs.

  3. Optionally set a topic query such as ai or a location such as london.

  4. Set maxItems to the number of events you want.

  5. Choose whether to include public host names.

  6. Turn on event detail enrichment if you need descriptions from individual event pages.

  7. Click Start.

  8. Export the dataset or connect it to your workflow.

Input settings

JSON key Type Description
startUrls array Public Luma event, calendar, place, category, or discover URLs.
query string Optional topic/category such as ai, tech, or climate.
location string Optional city or place slug such as london or san-francisco.
dateFrom string Keep events starting on or after this ISO date or datetime.
dateTo string Keep events starting on or before this ISO date or datetime.
maxItems integer Maximum number of event rows to save.
includeHosts boolean Include public host names and links when visible.
includeEventDetails boolean Fetch event pages when more description details are needed.
proxyConfiguration object Optional Apify Proxy settings; default is no proxy.

Input options

Luma URLs

Use startUrls for exact public Luma URLs.

Examples:

  • https://luma.com/london?k=p
  • https://luma.com/ai?k=t
  • https://luma.com/claw?k=c
  • https://luma.com/your-event-slug

Topic query

Use query for a topic/category such as ai, tech, climate, food, wellness, or crypto.

Location

Use location for a city/place slug such as london, berlin, paris, amsterdam, or san-francisco.

Date filters

Use dateFrom and dateTo to keep events inside a date window.

Use ISO dates such as 2026-07-01 or 2026-12-31T23:59:59Z.

Maximum events

Use maxItems to control dataset size and cost.

Host fields

Use includeHosts to include public host names and links when visible.

Detail enrichment

Use includeEventDetails when listing pages do not contain descriptions and you want the actor to fetch individual event pages.

Example input

{
  "startUrls": [
    { "url": "https://luma.com/london?k=p" }
  ],
  "query": "ai",
  "location": "london",
  "maxItems": 25,
  "includeHosts": true,
  "includeEventDetails": false
}

Example output

{
  "eventUrl": "https://luma.com/example-event",
  "eventId": "evt-example",
  "eventTitle": "AI Founders Meetup",
  "eventDescription": "Public event description...",
  "startDate": "2026-07-15T18:00:00.000Z",
  "endDate": "2026-07-15T20:00:00.000Z",
  "timezone": "Europe/London",
  "locationName": "London, United Kingdom",
  "address": "London, United Kingdom",
  "isOnline": false,
  "hostNames": ["Example Host"],
  "hostUrls": [],
  "calendarName": "Example Calendar",
  "calendarUrl": "https://luma.com/example-calendar",
  "imageUrl": "https://images.lumacdn.com/example.png",
  "tags": ["AI"],
  "priceText": "Free",
  "registrationStatus": "open",
  "sourceUrl": "https://luma.com/london?k=p",
  "scrapedAt": "2026-07-05T09:00:00.000Z"
}

Tips for better results

Start with specific Luma URLs whenever possible.

Use city pages for local event discovery.

Use calendar pages when you already know the organizer you want to monitor.

Use topic pages for market mapping.

Keep includeEventDetails off for fast listing runs.

Turn includeEventDetails on when descriptions are important.

Use date filters to remove past or out-of-window events.

Keep maxItems low during setup and increase it after checking the output.

Integrations

Send new Luma events to Google Sheets for sponsorship tracking.

Push event rows to Airtable for community calendar workflows.

Use Make or Zapier to alert a Slack channel when new events appear.

Export CSV files for sales research and account planning.

Feed dataset items into enrichment tools for organizer research.

Create recurring Apify schedules to monitor cities or calendars weekly.

API usage

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('<ANNA_APIFY_USERNAME>/luma-events-scraper').call({
  startUrls: [{ url: 'https://luma.com/london?k=p' }],
  maxItems: 25,
});
console.log(run.defaultDatasetId);

Python

from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('<ANNA_APIFY_USERNAME>/luma-events-scraper').call(run_input={
    'startUrls': [{'url': 'https://luma.com/london?k=p'}],
    'maxItems': 25,
})
print(run['defaultDatasetId'])

cURL

curl -X POST 'https://api.apify.com/v2/acts/<ANNA_APIFY_USERNAME>~luma-events-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://luma.com/london?k=p"}],"maxItems":25}'

Use with AI agents via MCP

Luma Events Scraper is available as a tool for AI assistants that support the Model Context Protocol (MCP).

Add the Apify MCP server to your AI client. This gives you access to all Apify actors, including <ANNA_APIFY_USERNAME>/luma-events-scraper.

Setup for Claude Code:

claude mcp add --transport http apify "https://mcp.apify.com"

Setup for Claude Desktop, Cursor, or VS Code:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com"
    }
  }
}

Your AI assistant will authenticate with your Apify account on first use.

Example prompts:

  • "Use <ANNA_APIFY_USERNAME>/luma-events-scraper to find the next 20 public Luma AI events in London."
  • "Scrape this Luma calendar and summarize the host names, dates, and locations."
  • "Create a table of upcoming Luma events from these city pages."

Scheduling

You can schedule this actor to run daily, weekly, or monthly.

For monitoring, use a stable set of calendar or city URLs.

Export the dataset after each run or connect the output to another actor.

Proxy and reliability notes

Most public Luma pages work without a proxy.

If your network is blocked, enable Apify Proxy in the input.

Keep large recurring runs conservative and use specific source URLs.

Limitations

The actor only extracts data that is publicly visible on Luma pages.

Some private venue details may be intentionally hidden by Luma or the event host.

Some listing pages may expose fewer event fields than individual event pages.

Dynamic search behavior can change as Luma updates its website.

Legality and ethical use

This actor is designed for public event metadata.

Do not use it to collect private attendee data or bypass access controls.

Respect Luma's terms, applicable privacy laws, and event host expectations.

Use the data for legitimate research, monitoring, aggregation, and business workflows.

Support

If a public Luma page does not extract as expected, open an Apify issue and include:

  • the input JSON you used;
  • the reproducible public URL that should return events;
  • the expected output fields or event count;
  • the actual output or run ID you received.

Include whether the page is a city, topic, calendar, or event page.

Common questions

Questions and answers reused from the canonical actor README.

Why are host fields empty?

Some Luma pages do not expose public host links, or you may have disabled includeHosts.

Why is the exact venue missing?

Many Luma hosts hide venue addresses until registration is approved. The actor only returns public location text.

Why did I get fewer events than maxItems?

The source page may contain fewer public events, or date filters may remove some rows.

How do I get descriptions?

Turn on includeEventDetails so the actor fetches individual event pages when needed.