🎟️ Luma Events Discovery Scraper

Discover and export public events from Luma by city, category, calendar, community, or event URL.

Get clean event schedules, public venues, ticket and availability signals, calendar metadata, and public organizer profiles in one dataset. No Luma account or API key is required.

Use the Actor for local event newsletters, event aggregation, sponsorship research, organizer outreach, community monitoring, venue analysis, and recurring event intelligence.

What does Luma Events Discovery Scraper do?

Luma Events Discovery Scraper turns public Luma discovery pages into structured records ready for JSON, CSV, Excel, APIs, webhooks, or downstream automations.

It supports five common workflows:

• 🌆 discover upcoming events from a public city page;
• 🧠 filter discovery by a Luma category such as AI, tech, crypto, or wellness;
• 📅 export upcoming or past events from a public calendar/community;
• 🎫 extract one individual public event;
• 🔎 combine several Luma URLs into one deduplicated dataset.

The Actor follows Luma's public web data layer and cursor pagination. It does not register for events, access host dashboards, or require private credentials.

Who is this Luma event scraper for?

Event aggregators and newsletter teams

Refresh upcoming events for a city or topic, then publish selected records to a website, newsletter, or calendar feed.

Community and event marketers

Track active calendars, compare event cadence, and identify organizers running events in a relevant market.

Sponsors and partnership teams

Build prospect lists from public event and host profiles, public websites, and social handles without collecting attendee data.

Venue and local-market analysts

Map publicly disclosed venues and understand which categories are active in each city.

Data and product teams

Power event-discovery products, recommendation pipelines, dashboards, alerts, or research datasets through the Apify API.

Why use this Actor?

• ⚡ HTTP-first extraction — no browser startup for the normal public route.
• 🔁 Cursor pagination — continues beyond the first page until your limit or source exhaustion.
• 🧹 Automatic deduplication — the same event from several inputs is saved and charged once.
• 🎯 Flexible inputs — event, calendar, city, category, and combined discovery pages.
• 🧾 Normalized output — one stable event schema across every supported source.
• 🔐 Public-only boundary — no attendee lists or authenticated host data.
• 📍 Address safeguards — registration-only addresses and restricted coordinates are omitted.
• 🛠️ Apify integrations — schedules, datasets, webhooks, API, Make, Zapier, n8n, and MCP.

Supported Luma URLs

Input type	Example	What it returns
City and category	https://luma.com/discover/sf/ai	Upcoming AI events around San Francisco
City	https://luma.com/sf	Upcoming public events in San Francisco
Category	https://luma.com/ai	Upcoming public AI events across discovery regions
Calendar/community	https://luma.com/guides_	Events from one public calendar
Individual event	https://luma.com/vs5ybrec	One public event with available detail

Both luma.com and legacy lu.ma URLs are accepted and normalized.

Unsupported external hosts fail closed instead of being fetched as arbitrary URLs.

How to scrape Luma events

1. Open the Actor's Input tab.
2. Add one or more public Luma URLs.
3. Set Maximum events to control dataset size and cost.
4. Optionally add date bounds.
5. For calendars, choose upcoming or past events.
6. Enable full event details only when you need descriptions and richer ticket context.
7. Click Start.
8. Open the Dataset tab to review or export the records.

Start with 10 events to validate your workflow, then increase the limit for scheduled production runs.

Input parameters

Field	Type	Default	Description
startUrls	array	SF AI discovery	Public event, calendar, city, category, or discovery URLs
maxItems	integer	25	Maximum unique events across all inputs
dateFrom	string	—	Inclusive ISO lower bound; date-only values begin at 00:00:00 UTC
dateTo	string	—	Inclusive ISO upper bound; date-only values include the full UTC calendar day
calendarPeriod	string	future	future or past for calendar inputs
enrichEventDetails	boolean	false	Fetch one public detail response per event
proxyConfiguration	object	—	Optional Apify Proxy configuration

Invalid dates, reversed date ranges, non-Luma URLs, and out-of-range limits produce an explicit failed run.

Basic input example

{
  "startUrls": [
    { "url": "https://luma.com/discover/sf/ai" }
  ],
  "maxItems": 25
}

Calendar monitoring example

{
  "startUrls": [
    { "url": "https://luma.com/guides_" }
  ],
  "maxItems": 100,
  "calendarPeriod": "future",
  "dateTo": "2026-09-30"
}

Run this input on a daily or weekly schedule and use event IDs to compare snapshots in your own database.

Enriched sponsorship research example

{
  "startUrls": [
    { "url": "https://luma.com/discover/sf/ai" },
    { "url": "https://luma.com/discover/nyc/tech" }
  ],
  "maxItems": 100,
  "enrichEventDetails": true
}

Detail enrichment can add descriptions, categories, counts, and richer public ticket context. It also adds one request per event, so leave it disabled when discovery-level fields are sufficient.

What data can you extract?

Field	Description
eventId	Stable public Luma event identifier
eventUrl	Canonical public event URL
name	Event name
startAt, endAt	ISO timestamps
timezone	Event IANA timezone
eventType, visibility	Public event state
description	Plain-text public description when enriched
coverUrl, socialImageUrl	Public event images
location	Location type and publicly disclosed venue/geography
ticketing	Free/paid, sold-out, capacity, approval, registration, and waitlist signals
calendar	Calendar/community identity, description, verification, and public links
hosts	Public host names, bios, verification, and social links
categories	Public Luma category names when enriched
sourceUrl	Input page that produced the event
scrapedAt	Extraction timestamp

Output example

{
  "eventId": "evt-XG7GDKbx8VOdjGi",
  "eventUrl": "https://luma.com/vs5ybrec",
  "name": "Design & Deploy Workshop",
  "startAt": "2026-07-20T01:00:00.000Z",
  "endAt": "2026-07-20T04:00:00.000Z",
  "timezone": "America/Los_Angeles",
  "eventType": "independent",
  "visibility": "public",
  "location": {
    "type": "offline",
    "venueName": "Homebrew Club",
    "city": "San Francisco",
    "region": "California",
    "country": "United States",
    "latitude": 37.7881264,
    "longitude": -122.4053777,
    "addressVisibility": "public"
  },
  "ticketing": {
    "isFree": true,
    "soldOut": false,
    "requiresApproval": false,
    "registrationAvailability": "open",
    "waitlistEnabled": false
  },
  "calendar": {
    "id": "cal-TrbezBvP8Yt9MlF",
    "name": "Guides",
    "url": "https://luma.com/guides_",
    "verified": true
  },
  "hosts": [
    {
      "id": "usr-82lWli9unCprzqU",
      "name": "Saurabh K",
      "instagram": "https://instagram.com/saurabh_k_00000",
      "verified": false
    }
  ],
  "categories": [],
  "sourceUrl": "https://luma.com/discover/sf/ai",
  "scrapedAt": "2026-07-20T03:45:00.000Z"
}

Fields unavailable on a particular public page are omitted rather than invented.

Venue and address privacy

Luma sometimes hides a venue until a guest registers or is approved.

When Luma marks an address as restricted or obfuscated, this Actor:

• keeps broad public geography such as city, region, and country;
• marks addressVisibility as restricted;
• omits the venue name and full address;
• omits latitude and longitude, even if an approximate internal coordinate is present.

The Actor never registers to unlock a location.

Ticket and availability signals

Depending on the event and input route, ticketing can include:

• whether registration is free;
• minimum and maximum displayed price;
• sold-out and near-capacity state;
• remaining spots;
• whether host approval is required;
• registration availability;
• waitlist status;
• public aggregate guest and ticket counts.

These fields are observations, not a booking guarantee. Availability can change after the run completes.

How much does it cost to scrape Luma events?

The Actor uses pay-per-event pricing:

• a small $0.005 start fee per run;
• one item event per unique event saved;
• tiered per-event pricing based on your Apify plan.

At the formula-derived BRONZE rate of $0.000093301 per event, 1,000 unique event records add about $0.0933 plus the start fee. The live Actor pricing table is authoritative and includes plan-based tier discounts.

Duplicate events are not charged twice in the same run. Runs that fail before valid extraction do not emit item charges.

Pagination and limits

Discovery and calendar endpoints are paginated automatically.

maxItems is a run-wide limit, not a per-URL limit. If you provide three sources and set maxItems to 100, the Actor stops after 100 unique qualifying events total.

Date filters are applied before saving. A page can therefore be fetched even when all of its events are later excluded.

Scheduling recurring monitors

For a recurring monitor:

1. save a task with stable discovery or calendar URLs;
2. keep a bounded maxItems appropriate for the source;
3. schedule the task daily or weekly;
4. send the dataset to your database or webhook;
5. key records by eventId;
6. compare startAt, venue, and ticketing fields to detect changes.

Apify schedules and webhooks make this workflow code-free.

Export and integrations

Results can be exported as JSON, CSV, Excel, XML, RSS, or HTML.

Useful integration patterns include:

• Google Sheets — append a weekly local-event shortlist;
• Airtable — maintain an event sponsorship pipeline;
• Make or Zapier — notify a team when a matching event appears;
• n8n — enrich public organizer websites in a lead workflow;
• Slack or email — send a daily calendar digest;
• BigQuery or Snowflake — analyze event volume and venue trends;
• webhooks — trigger your application as soon as a run finishes.

JavaScript API example

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/luma-events-discovery-scraper').call({
  startUrls: [{ url: 'https://luma.com/discover/sf/ai' }],
  maxItems: 25,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python API example

from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/luma-events-discovery-scraper').call(run_input={
    'startUrls': [{'url': 'https://luma.com/discover/sf/ai'}],
    'maxItems': 25,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)

cURL API example

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~luma-events-discovery-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url": "https://luma.com/discover/sf/ai"}],
    "maxItems": 25
  }'

After the run succeeds, read its defaultDatasetId from the run response and download the items through the Dataset API.

Use with Apify MCP

Connect the Actor to AI assistants through Apify MCP.

Claude Code setup

claude mcp add --transport http apify \
  "https://mcp.apify.com/?tools=automation-lab/luma-events-discovery-scraper"

Claude Desktop setup

Add this server to your Claude Desktop MCP configuration:

{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com/?tools=automation-lab/luma-events-discovery-scraper"
    }
  }
}

Cursor setup

Open Cursor Settings → MCP, add a server named apify, and use the same mcpServers JSON and URL shown above.

VS Code setup

Open your MCP server settings in VS Code, create an HTTP server named apify, and set its URL to the same actor-specific Apify MCP URL.

Example prompts:

• “Find the next 25 public AI events in San Francisco and group them by week.”
• “Export upcoming events from this Luma calendar and identify public organizer websites.”
• “Compare public ticket availability for these Luma event URLs.”
• “Create a sponsorship shortlist from public tech-event hosts in New York.”

Tips for reliable runs

• Use canonical public Luma URLs copied from your browser.
• Start with 10–25 events before scaling a new workflow.
• Leave detail enrichment off when you only need discovery fields.
• Prefer city/category URLs over broad category-only inputs for local research.
• Use ISO date strings with an explicit timezone when hour-level boundaries matter.
• Add a proxy only after direct access shows repeatable rate limiting.
• Schedule moderate refresh intervals instead of repeatedly polling the same page.

Limitations

• Luma can change its public web data layer without notice.
• Category-only discovery can reflect Luma's current geographic ranking.
• Some ticket fields only appear on enriched event details.
• Private events, guest-only venues, and authenticated calendars are outside scope.
• The Actor does not collect attendee lists or registration answers.
• Restricted virtual join links are not exposed.
• Results represent source state at extraction time.

Troubleshooting

Why did my run fail with “Unsupported URL”?

Only HTTPS URLs on luma.com or lu.ma are accepted. Remove shortened links on other domains and copy the canonical public Luma URL.

Why are venue coordinates missing?

Luma marked the address restricted, guests-only, or obfuscated. The omission is intentional so the Actor does not leak registration-only location data.

Why did date filters return no records?

Confirm the dates are valid ISO values and that dateFrom is not later than dateTo. A date-only bound uses a UTC calendar day: dateFrom starts at 00:00:00 UTC and dateTo includes through 23:59:59.999 UTC. ISO date-times use their exact timestamp and offset. Calendar pages default to upcoming events; set calendarPeriod to past when needed.

Why is the description missing?

Enable Fetch full event details. Discovery pages often include enough schedule and organizer data but not the full public description.

What should I do about HTTP 403 or 429 errors?

Retry after a reasonable delay. If direct anonymous access is consistently limited, configure an Apify Proxy in the advanced input section.

Is scraping public Luma data legal?

This Actor is designed for anonymously accessible public event metadata.

You are responsible for your use case, compliance with applicable law, Luma's terms, intellectual-property rights, privacy rules, and reasonable request rates. Do not use results for spam or intrusive profiling.

The Actor intentionally excludes private attendee lists, registration answers, authenticated host information, registration-only addresses, and restricted coordinates.

Related event scrapers

• Eventbrite Scraper — discover public Eventbrite listings and event details.
• Meetup Scraper — collect public Meetup groups and events for community research.

Combine sources in your own database using source URLs and stable event identifiers.

FAQ

Does this Actor require a Luma login?

No. The supported product scope uses public anonymous pages and data endpoints.

Can it scrape attendee or guest lists?

No. Attendee extraction is intentionally outside scope.

Can I scrape several cities in one run?

Yes. Add several city or city/category URLs to startUrls. maxItems applies across the whole run.

Does it support past events?

Yes for public calendar/community URLs by setting calendarPeriod to past. Discovery pages primarily expose upcoming events.

Are duplicates removed?

Yes. Events are deduplicated by stable Luma event ID within each run.

Can I fetch full ticket tiers and descriptions?

Enable enrichEventDetails. Availability varies by what each event publishes publicly.

Can I use the results commercially?

That depends on your jurisdiction, source terms, and use case. Obtain legal advice when needed and avoid spam or privacy-invasive processing.

How fresh is the data?

Each run requests the current public source. Use Apify schedules for recurring refreshes.

Start building your Luma event dataset

Add a city/category page, keep the first run small, and export a clean dataset of public Luma events in minutes.