# Luma Events API — Events by City, Category & Calendar (`insight.solutions/luma-events-api`) Actor

Upcoming Luma (lu.ma) events as clean rows: every AI, tech or startup meetup in a city, a category or a calendar, with start time, venue, price, capacity, guest count and organiser calendar. Descriptions and ticket types on request. Host names are never included. No login, no browser.

- **URL**: https://apify.com/insight.solutions/luma-events-api.md
- **Developed by:** [Insight Solutions](https://apify.com/insight.solutions) (community)
- **Categories:** Business, Marketing, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 events

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 API — Events by City, Category & Calendar

Every upcoming Luma (lu.ma) event in a city, a category or a calendar, as clean
rows: name, start and end time, timezone, venue and address, city and
coordinates, price and currency, sold-out and waitlist state, spots left, guest
count, and the organising calendar. Turn on details for each event's
description (plain text or Markdown), ticket types and categories. Filter by
keyword, date window, in person or online, and free only. No login, no browser,
no key — and no host's name, handle or photo, ever.

Luma is where a large share of tech, AI and startup meetups are listed now, and
it serves its event data as JSON to every visitor. This Actor reads that JSON —
the same data Luma's own pages are built from — rather than the HTML around
it.

### At a glance

**Input** — this is the Store prefill; paste it and run:

```json
{ "mode": "place", "places": ["sf"], "maxEventsPerSource": 25 }
```

The next 25 events in San Francisco, soonest first, plus one free row
describing what was read. It is one 145 KB request.

**Output** — one row per event; the fields you will use most are `name`,
`startAt`, `venueName`, `address`, `city`, `isFree`, `price`,
`registrationStatus`, `guestCount`, `calendarName` and `url` (full list under
*Output reference*). Anything that could not be read — an unknown city, a
private event, a blocked request — comes back as a free diagnostic row
(`rowType: "diagnostic"`, `errorType`, `error`) instead of a charge.

**Price** — **$1.00 per 1,000 events** on the FREE tier (+ $0.001 per run,
charged only once a run has returned an event). City, category, source and
diagnostic rows are free, so are events your filters exclude, and a run that
returns nothing bills nothing at all. Pay per event, limited permissions —
works over the Apify MCP server (`mcp.apify.com`) and with agentic (x402)
payments.

**From code** —
`client.actor("insight.solutions/luma-events-api").call(run_input={…})`
with `apify-client`, or `POST
https://api.apify.com/v2/acts/insight.solutions~luma-events-api/run-sync-get-dataset-items`.

***

### Who it is for

- **Event marketers and community teams** — every AI, crypto or climate event
  in the cities you cover, with dates, venues, capacity and the communities
  running them, refreshed on a schedule.
- **Sponsorship and partnerships** — which organisations host the most events,
  how full they get (`guestCount`, `isSoldOut`, `waitlist`), and where.
- **Researchers and newsletters** — a week's or a month's events in a city as
  one table (`startAfter` / `startBefore`), with Markdown descriptions ready to
  summarise.
- **Founders and job seekers** — the meetups worth going to, filtered to free
  and in person.

***

### What you get

An **event** (from the San Francisco prefill; null columns cut):

```json
{
  "ok": true,
  "rowType": "event",
  "input": "sf",
  "source": "place:sf",
  "sourceUrl": "https://api.lu.ma/event/get?event_api_id=evt-D083fftWbb5Dpqv",
  "eventId": "evt-D083fftWbb5Dpqv",
  "slug": "init-conf",
  "url": "https://luma.com/init-conf",
  "name": "init() by WorkOS",
  "startAt": "2026-10-07T15:00:00Z",
  "endAt": "2026-10-08T00:00:00Z",
  "timezone": "America/Los_Angeles",
  "locationType": "offline",
  "venueName": "SFJAZZ",
  "address": "SFJAZZ, 201 Franklin St, San Francisco, CA 94102, USA",
  "city": "San Francisco",
  "region": "California",
  "country": "United States",
  "countryCode": "US",
  "latitude": 37.7764351,
  "longitude": -122.421631,
  "addressVisibility": "public",
  "coverUrl": "https://images.lumacdn.com/uploads/bt/3bcd166d-cf3c-4d92-af57-2686f9de44da.gif",
  "isFree": true,
  "isSoldOut": false,
  "isNearCapacity": false,
  "requireApproval": true,
  "registrationStatus": "open",
  "waitlist": false,
  "guestCount": 0,
  "ticketCount": 0,
  "hostCount": 1,
  "verifiedHostCount": 0,
  "calendarKind": "organization",
  "calendarId": "cal-Z1tslEBMjjCh4fd",
  "calendarName": "WorkOS Events",
  "calendarWebsite": "https://workos.com",
  "calendarAvatarUrl": "https://images.lumacdn.com/calendars/xz/a7cb4c75-9cbd-4853-8012-496c5ef3eb77.png",
  "rank": 1
}
```

A paid, sold-out one:

```json
{
  "name": "NeoCloud Summit 2026 — Where the Next Cloud Gets Built",
  "isFree": false,
  "price": 995,
  "currency": "USD",
  "isSoldOut": true,
  "spotsRemaining": 0,
  "registrationStatus": "sold-out",
  "calendarName": "Ignite Community"
}
```

An event whose organiser shows the address to registered guests only — the
city is given, the street is not, and Luma's approximate point is rounded:

```json
{
  "name": "Hardware hackathon: turn a vintage toy into a voice agent",
  "venueName": null,
  "address": null,
  "city": "San Francisco",
  "latitude": 37.8,
  "longitude": -122.4,
  "addressVisibility": "guests-only"
}
```

With `includeDetails` (and always in `events` mode) the row also carries the
description, ticket types and the rest:

```json
{
  "description": "WorkOS presents [**init(): the conference for builders**](https://workos.com/init).  \n\nJoin the founders, engineers, and technical leaders shaping what’s next. …",
  "descriptionFormat": "markdown",
  "categories": ["AI"],
  "ticketTypes": [{ "name": "Standard", "type": "free", "price": null, "registered": 1060, "requireApproval": true, "isHidden": false }],
  "sessionCount": 0,
  "faqCount": 0,
  "registrationQuestionCount": 7,
  "locale": "en"
}
```

And one free **source** row per city, category or calendar, saying what was
read: `eventsFound`, `eventsReturned`, `eventsFiltered`, `duplicatesSkipped`,
`pages`, `capReached` and `hasMore`.

***

### Quick start

1. Pick **What to read**: cities, categories, calendars, or single events.
2. Fill that list — `sf`, `https://lu.ma/ai`, a calendar's link, event links.
   Don't know the slug? Run mode **discover** once: it lists every city and
   category Luma has, with its id and slug, free.
3. Optionally narrow it: **Keyword**, **Starting on or after / before**, **In
   person or online**, **Free events only**.
4. Turn on **Include details** for descriptions and ticket types, set **Max
   events per source**, and run. Rows arrive soonest first.

***

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `mode` | select | `place` | `place`, `category`, `calendar`, `events` or `discover`. Each mode reads only its own list. |
| `places` | string\[] | prefill `["sf"]` | City slugs (`sf`, `nyc`, `london`), links (`https://lu.ma/sf`), ids (`discplace-…`) or names as Luma shows them (`San Francisco`). |
| `categories` | string\[] | `[]` | Category slugs (`ai`, `tech`, `climate`), links, ids (`cat-ai`) or names (`Food & Drink`). |
| `calendars` | string\[] | `[]` | Calendar slugs (`genai-sf`), links or ids (`cal-…`). |
| `events` | string\[] | `[]` | Event links (`https://lu.ma/init-conf`), slugs or ids (`evt-…`). |
| `keyword` | string | `""` | Whole words, any case, comma-separated alternatives (`AI, LLM, agents`). Matches the event name; with details on, the description too. |
| `startAfter` / `startBefore` | string | — | `2026-11-01` is a calendar day in each event's own timezone; `2026-11-01T18:00:00Z` is an exact instant (UTC when no zone is given). `startBefore` excludes the day itself, so `2026-11-01` … `2026-12-01` is November. |
| `locationType` | select | `any` | `offline` keeps in-person events, `online` the rest. |
| `freeOnly` | boolean | `false` | Only events whose registration is free. |
| `includeDetails` | boolean | `false` | Description, ticket types, categories, session/FAQ/registration-question counts, refund policy: one extra request per event, same price. |
| `descriptionFormat` | select | `text` | `text` or `markdown`. |
| `maxEventsPerSource` | integer | 100 (prefill 25) | 1–10,000 paid events from each city, category or calendar. |
| `maxEventsTotal` | integer | 1000 | 1–100,000 paid events in the whole run. |
| `maxConcurrency` | integer | 3 | Sources read at once (1–10). |
| `maxRunSecs` | integer | 240 | 30–3,600. Rows already returned are kept when it runs out. |
| `proxyConfiguration` | object | `{ "useApifyProxy": true }` | Apify datacenter proxy by default; switch to residential if you see `blocked` rows. |

Links on `lu.ma` and `luma.com` are both accepted (`lu.ma` now redirects to
`luma.com`, so every `url` in the output is a `luma.com` link). Duplicates are
dropped on what they resolve to, so `sf`, `https://lu.ma/sf` and its
`discplace-` id are one city.

A run with nothing usable to read — an empty list for the chosen mode, entries
that are not Luma's, a date that is not a date, `startAfter` not before
`startBefore` — finishes **FAILED** before a single request, with a free row
saying which entry was the problem. A date typo is refused rather than ignored,
so it can never turn a filtered run into an unfiltered (and billed) one.

***

### Output reference

Every row has the same columns, `null` where a column does not apply, so the
dataset exports as one table.

**On every row:** `ok`, `rowType` (`event` · `place` · `category` · `source` ·
`diagnostic`), `input` (your entry, as typed), `error`, `errorType`,
`scrapedAt`, `source` (`place:sf`, `category:ai`, `calendar:cal-…`, `event`,
`discover`), `sourceUrl`.

**Events:**

| Column | What it is |
|---|---|
| `eventId`, `slug`, `url` | Luma's id (`evt-…`), the event's path, and its page on luma.com. |
| `name` | The name as the organiser published it. |
| `startAt`, `endAt`, `timezone` | UTC with a `Z`, and the event's own IANA timezone. |
| `locationType` | As Luma sends it: `offline` is in person. |
| `venueName`, `address` | The venue's name (when Luma has a named place) and the full street address. Both `null` when the organiser shows the address to guests only. |
| `city`, `region`, `country`, `countryCode` | Given even when the street address is hidden. |
| `latitude`, `longitude`, `addressVisibility` | The point Luma shows. For a guests-only address Luma's point is approximate, so it is rounded to two decimals (about 1 km) and `addressVisibility` is `guests-only`. |
| `coverUrl` | The cover image. |
| `isFree`, `price`, `maxPrice`, `currency` | Price in currency units (Luma sends cents: `99500` is `995`), ISO currency code. |
| `isSoldOut`, `spotsRemaining`, `isNearCapacity`, `requireApproval` | Capacity and approval, as Luma shows them. |
| `registrationStatus`, `waitlist` | `open`, `waitlist` or `sold-out`; whether new registrations go to the waitlist. |
| `guestCount`, `ticketCount` | Numbers only — no guest is ever named. |
| `hostCount`, `verifiedHostCount` | How many hosts, and how many Luma has verified. Never who. |
| `calendarKind` | `organization` or `personal`. |
| `calendarId`, `calendarName`, `calendarSlug`, `calendarUrl`, `calendarWebsite`, `calendarAvatarUrl` | The organisation calendar running the event. All `null` for a personal calendar — see below. |
| `rank` | 1 for the first event a source returned, then 2, 3… in Luma's order (start time). In `events` mode, the link's position in your list. |
| `description`, `descriptionFormat` | With details: the description as text or Markdown (headings, bold, italic, links, lists, images). |
| `ticketTypes` | With details: name, type, price, min price, currency, flexible, capacity, spots left, how many registered, approval, hidden and disabled flags, sale window, description. |
| `categories` | With details: the Luma categories the event is in, by name. |
| `sessionCount`, `faqCount`, `registrationQuestionCount` | With details: counts only. Registration questions and answers are never included. |
| `refundPolicy`, `locale` | With details. |

**Place and category rows** (free, `discover` mode): `placeId` or
`categoryId`, `slug`, `name`, `url`, `eventCount`, `timezone`, `latitude`,
`longitude` and `description` for cities; `upcomingEventCount` for categories.

**Source rows** (free, one per source): `eventsFound`, `eventsReturned`,
`eventsFiltered`, `duplicatesSkipped`, `pages`, `capReached`, `hasMore`, plus
the city's, category's or calendar's id and name.

**Diagnostic rows** (free):

| `errorType` | Meaning |
|---|---|
| `invalid-input` | An entry that is not a Luma slug, link or id, an id in the wrong list, a page of the wrong kind (a category in `places`), or a date filter that is not a date. |
| `not-found` | Luma has no such city, calendar or event, or refuses it (private, removed). |
| `blocked` | A 403, 429 or bot-protection page, twice, from two exit IPs. |
| `timeout` | A request that did not answer in time, or the run's time budget running out. Rows already returned are kept. |
| `parse-failed` | A page or answer without the data this Actor reads — Luma may have changed its format. |
| `robots-disallowed` | A luma.com path that luma.com/robots.txt disallows. Not requested. |
| `http` | Any other upstream error, such as Luma refusing a continuation cursor. |
| `internal` | This Actor's own error. The run is then FAILED. |

***

### How Luma is read

| What | Request | Notes |
|---|---|---|
| A city | `api.lu.ma/discover/get-paginated-events?discover_place_api_id=…`, 25 per page | Paged with Luma's own opaque cursor, passed back exactly as sent. The id of the 87 cities Luma lists is built in, so a city slug costs no extra request. |
| A calendar | `api.lu.ma/calendar/get-items?calendar_api_id=…&period=future`, 20 per page | A slug is first resolved from the calendar's page. |
| A category | `luma.com/<category>` | A category page lists calendars, not events. The Actor reads the upcoming events of the calendars the page features — page 1 of each, merged by start time, then a further page of one calendar only when its events are next. |
| One event | `api.lu.ma/event/get?event_api_id=…` or `api.lu.ma/url?url=<slug>` | For a link or slug, the event's page is the fallback when the API cannot be read. |
| Details | `api.lu.ma/event/get` per event | Only with `includeDetails`. |
| Discover | `luma.com/discover` | The list of cities and categories. |

Each source gets **one request in flight, 250–600 ms apart**, through its own
proxy session, however many sources run at once (in `events` mode, the links
one worker reads share its session and its pacing). A city or calendar walk
stops as soon as Luma's events pass your `startBefore`, since Luma lists them
by start time. `luma.com/robots.txt` is read once per run, before the first
page, and every rule in it is honoured for this Actor too — including the ones
it addresses only to one search engine's crawler (`/in/`, `/company/`,
`/session-*`, `/social-share`). A run that reads no page (a city in the
catalog, a calendar or event by id) never fetches it.

**Host names are never included.** Luma's event data lists the people hosting
each event — names, usernames, photos, bios, social handles — and the guests it
features. This Actor never copies any of them: you get `hostCount` and
`verifiedHostCount`, and nothing else about a person. A calendar is identified
only when Luma marks it as an organisation's; a person's own calendar comes
back as `calendarKind: "personal"` with its name, link and picture left out,
and a calendar source of that kind is labelled `calendar:personal`. Payment
accounts, coupon codes, tracking pixels and crypto-wallet requirements are
never read into a row, and registration questions are only counted. Event
names, descriptions and venue addresses are the organiser's published copy and
are returned as Luma serves them.

***

### What you are never charged for

- Every `place`, `category` and `source` row.
- Every `diagnostic` row: unknown cities, private or removed events, blocked
  requests, timeouts, pages Luma changed, paths robots.txt disallows.
- Events your filters exclude — keyword, dates, in person or online, free only.
- An event reached a second time in a run, from another source or another page
  (it is a duplicate, counted on the source row).
- The detail request behind `includeDetails`: same price per event.
- A run that returns nothing at all: it finishes **SUCCEEDED with zero
  results** and a "0 results … Nothing was charged." status message naming the
  diagnostic rows by type, and bills nothing, **start fee included**.

***

### Pricing

| Event | What it is | FREE | BRONZE | SILVER | GOLD |
|---|---|---|---|---|---|
| `actor-start` | Charged once per run, only after the run has returned an event | $0.001 | $0.001 | $0.001 | $0.001 |
| **`event`** | One event row, with or without details | **$0.001** | **$0.001** | **$0.0008** | **$0.0006** |

**$1.00 per 1,000 events.**

| Run | Cost |
|---|---|
| The default input — 25 events in San Francisco | **$0.026** |
| Every upcoming event in San Francisco (74 on 2026-10-07) | **$0.075** |
| 1,000 events across ten cities | **$1.001** |
| The same 1,000 at GOLD | **$0.601** |
| Discover mode — every city and category with its id | **$0.00** |

Charging is charge-after-push: rows are in your dataset before the event is
recorded. `ACTOR_MAX_TOTAL_CHARGE_USD` is respected — the run stops fetching
when it is reached and finishes SUCCEEDED saying so.

***

### Proxy

The default is `{ "useApifyProxy": true }` — Apify's **datacenter** pool. The
capture probe read every endpoint above through it. A 403 or 429 is treated as
a block: that source's proxy session is rotated once, and a second refusal
becomes a free `blocked` row rather than a retry loop. A JSON 403 from Luma
itself (a private event) is reported as `not-found` straight away — asking
again from another address would not change the answer. If `blocked` rows
become common, switch `proxyConfiguration` to residential.

***

### Use it from an AI agent, or from code

One JSON object in, one flat array out — the shape agent runtimes want. The Actor runs with **limited permissions**, uses **pay-per-event** pricing and never enters Standby, so it works over the Apify MCP server and with x402 agentic payments. The **Integrations** tab pushes results to Slack, a webhook, Zapier, Make, Google Sheets, Snowflake or BigQuery.

```bash
curl -X POST "https://api.apify.com/v2/acts/insight.solutions~luma-events-api/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"place","places":["sf","nyc"],"keyword":"AI","startAfter":"2026-11-01","startBefore":"2026-12-01","maxEventsPerSource":100}'
```

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("insight.solutions/luma-events-api").call(run_input={
    "mode": "category",
    "categories": ["ai", "climate"],
    "freeOnly": True,
    "includeDetails": True,
    "descriptionFormat": "markdown",
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["rowType"] == "event":
        print(row["startAt"], row["city"], row["name"], row["calendarName"], row["url"], sep=" | ")
    elif row["rowType"] == "diagnostic":
        print("could not read", row["input"], row["errorType"], row["error"])
```

***

**Building an app with Lovable?** Apify's Lovable connector runs any Actor from inside a Lovable project with your Apify token. Connect Apify in Lovable once, then ask it: *"Use Apify to run insight.solutions/luma-events-api for my city and build an events calendar around the results."* At the default settings a run finishes well inside Lovable's 300-second synchronous limit, and every result is one JSON object per row, so the generated app needs no extra parsing. Usage bills to the Apify account whose token is connected.

### FAQ

**Do I need a Luma account or an API key?** No. Only what Luma shows any
visitor is read.

**How do I find a city's or category's slug?** Run `mode: "discover"` once. It
returns every city (87 when this was written) and category (12) with its id,
slug and event count, as free rows.

**Is a category every event Luma tags with it?** No — and this is worth
knowing. A Luma category page lists *calendars* (communities and conference
calendars), not events, so `category` mode returns the upcoming events of the
calendars the category page features, merged by start time. For "every AI
event in a city", use `place` mode with `keyword: "AI"`, and turn on
`includeDetails` to search descriptions too.

**Why is `address` empty for some events?** The organiser chose to show it to
registered guests only. The city, region and country are still given, and an
approximate point rounded to about a kilometre.

**Why are host names missing?** By design: hosts are people, and only their
count is returned. Organisation calendars are identified by name; a person's
own calendar is not.

**Does `startAfter` use UTC?** A bare date is a day in each event's own
timezone, so `2026-11-01` keeps a 7 pm talk in San Francisco on 1 November
even though it is 2 November in UTC. A full timestamp is exact.

**How many events can I get?** Up to 10,000 per source and 100,000 per run. A
source stops after reading 5,000 events, so a narrow filter on a very large
calendar may not reach its end; its source row then says Luma had more.

***

### Limitations

- **Category mode reads the calendars a category page features**, not a full
  category index (see the FAQ). Luma offers no category event list to
  visitors; the endpoint that looks like one answers 404.
- **Upcoming events only** in `place`, `category` and `calendar` modes: the
  lists Luma serves start from now.
- `includeDetails` costs one request per event, paced at 250–600 ms within a
  source: one to two events a second per source. Several sources run at once
  (`maxConcurrency`); raise `maxRunSecs` for large detailed runs — the default
  240 seconds covers a few hundred detailed events per source.
- **Host names are never included, by design** (see *How Luma is read*).
- Prices are read as Luma's cents divided by 100. Currencies without minor
  units have not been seen in a capture yet.
- The upstream format may change: this Actor reads Luma's JSON as it is served
  today, leaves a column `null` when an event does not carry it, and returns a
  free `parse-failed` row rather than a wrong one when a page no longer has the
  data it expects.
- Not affiliated with Luma. "Luma" is used only to say whose public event pages
  are read.

**Related:** to keep only the *new* events of a calendar between runs, put
this Actor on a schedule and compare `eventId`s; to read an event's own
website, use
[Website to Markdown — Content Extractor for LLMs & RAG](https://apify.com/insight.solutions/website-content-extractor).

### Our other Actors

Every Insight Solutions Actor is pay-per-result with no browser, no login and no API key, and every one of them returns free diagnostic rows instead of billing for failures. Prices are per 1,000 results.

**Video, audio & social**

- [YouTube Transcript API](https://apify.com/insight.solutions/youtube-transcript-api) — captions as timed segments, text, SRT or VTT, with language fallback and translation.
- [YouTube Comments API](https://apify.com/insight.solutions/youtube-comments-api) — comments and replies with likes, pinned and hearted flags, newest or top sort.
- [YouTube Channel API](https://apify.com/insight.solutions/youtube-channel-api) — a channel's videos, Shorts and live streams, plus YouTube search.
- [Podcast Search, Episodes & Charts API](https://apify.com/insight.solutions/podcast-api) — Apple Podcasts search, charts and full episode feeds.
- [Bluesky Scraper](https://apify.com/insight.solutions/bluesky-scraper) — profiles, posts, followers and follows from the public AT Protocol API.
- [Telegram Channel Scraper](https://apify.com/insight.solutions/telegram-channel-scraper) — posts, views and channel stats from public Telegram channels.
- [Substack Scraper](https://apify.com/insight.solutions/substack-scraper) — posts with full free text, comments and publication profiles.
- [Hacker News API](https://apify.com/insight.solutions/hacker-news-api) — stories, comments, users, front page and a structured "Who is hiring?" parser from the official HN APIs.
- [GitHub Repos, Trending & Releases API](https://apify.com/insight.solutions/github-repos-api) — repository facts, trending lists, releases and search, no token needed for small runs.
- [Discourse Forum API](https://apify.com/insight.solutions/discourse-forum-api) — topics, posts and categories from any Discourse community via its own JSON endpoints, usernames only.

**News, documents & the web**

- [Google News Search, Topics & Real Article URLs](https://apify.com/insight.solutions/google-news-api) — news search and topic feeds with the publisher's real URL decoded.
- [Website to Markdown — Content Extractor for LLMs & RAG](https://apify.com/insight.solutions/website-content-extractor) — any site as clean Markdown, text and heading-aware chunks.
- [WordPress Posts & Pages API](https://apify.com/insight.solutions/wordpress-posts-api) — posts and pages from any WordPress site as clean text or Markdown, with categories, tags and images.
- [Website Metadata API](https://apify.com/insight.solutions/website-metadata-api) — any URL's meta tags, Open Graph, Twitter cards, hreflang, feeds, JSON-LD and microdata, with normalised Product, Article, Event and FAQ entities.
- [Subdomain Finder API](https://apify.com/insight.solutions/subdomain-finder-api) — every subdomain of a domain from certificate-transparency logs, resolved over DNS, with an optional live HTTP check.
- [Internet Archive API](https://apify.com/insight.solutions/internet-archive-api) — archive.org search, item metadata, files and reviews.
- [Wayback Machine Toolkit](https://apify.com/insight.solutions/wayback-toolkit) — archived URL inventories, snapshots and text diffs between dates.
- [Website Technology Detector](https://apify.com/insight.solutions/website-tech-detector) — the tech stack behind any site, with the evidence for each detection.
- [Domain Intelligence API](https://apify.com/insight.solutions/domain-intelligence-api) — DNS, RDAP registration, TLS certificate and HTTP facts in one row per domain.
- [SEO Page Audit](https://apify.com/insight.solutions/seo-page-audit) — sitemap crawl with on-page checks, structured data and broken-link reports.
- [Keyword Suggestions API](https://apify.com/insight.solutions/keyword-suggestions-api) — Google, YouTube, Bing, Amazon and eBay autocomplete with alphabet and question expansions.
- [Website Contact Extractor](https://apify.com/insight.solutions/website-contact-extractor) — emails, phone numbers and social profiles from any list of websites.
- [Web Search Results API](https://apify.com/insight.solutions/web-search-api) — Bing and DuckDuckGo organic results with snippets, no key, no browser.
- [Company Enrichment API](https://apify.com/insight.solutions/company-enrichment-api) — a domain in, a company profile out: firmographics, contacts, tech stack, DNS and hiring signal.
- [Company Dossier API](https://apify.com/insight.solutions/company-dossier-api) — one company in, twelve sections out: profile, tech, contacts, DNS, open roles, news, SEC filings, federal awards, recalls, YC batch and apps.
- [Press Releases API](https://apify.com/insight.solutions/press-releases-api) — GlobeNewswire and PR Newswire releases plus any newsroom feed, by keyword, company, ticker or subject.
- [Federal Register API](https://apify.com/insight.solutions/federal-register-api) — rules, proposed rules, notices and the Public Inspection desk with dockets, comment deadlines and CFR references.
- [Academic Papers Search API](https://apify.com/insight.solutions/academic-papers-api) — OpenAlex, Crossref, arXiv and PubMed in one row per paper: abstract, citations, open-access PDF, authors and venue.
- [RSS & Atom Feed Monitor](https://apify.com/insight.solutions/rss-feed-monitor) — any RSS, Atom or JSON feed (or an OPML file) in, only the new items out, with keyword filters and a webhook.
- [Website Change Monitor](https://apify.com/insight.solutions/website-change-monitor) — watch any pages, diff the text between runs, get change rows with added/removed lines, keyword alerts and a webhook.
- [Wikipedia & Wikidata API](https://apify.com/insight.solutions/wikipedia-api) — article text, search, daily pageviews and Wikidata entity facts, any language edition.

**Business, finance & jobs**

- [Congress & Insider Trades API](https://apify.com/insight.solutions/congress-insider-trades-api) — STOCK Act periodic transaction reports and SEC Form 4 insider trades in one schema.
- [Federal Contracts, Grants & Lobbying API](https://apify.com/insight.solutions/federal-contracts-grants-api) — SAM.gov opportunities, USAspending awards, Grants.gov notices and Senate lobbying filings in one schema.
- [SEC EDGAR API](https://apify.com/insight.solutions/sec-edgar-api) — filings, XBRL financials and full-text search by ticker or CIK.
- [Clinical Trials & FDA API](https://apify.com/insight.solutions/clinical-trials-fda-api) — ClinicalTrials.gov studies plus openFDA recalls, labels, approvals, 510(k)s and adverse-event reports.
- [Product & Vehicle Recalls API](https://apify.com/insight.solutions/product-recalls-api) — CPSC, NHTSA, FDA and USDA recalls, vehicle complaints and ratings, plus a VIN decoder.
- [Y Combinator Companies, Batches & Founders](https://apify.com/insight.solutions/yc-companies-directory) — the YC directory with founders and social links, filterable by batch, industry and hiring status.
- [Career Site Jobs API](https://apify.com/insight.solutions/ats-jobs-api) — jobs straight from Greenhouse, Lever, Ashby, Workable and 10+ other ATS career sites.
- [Workday Jobs API](https://apify.com/insight.solutions/workday-jobs-api) — every posting on any Workday career site, with facets, search, posted dates and full descriptions.
- [New Job Postings Monitor](https://apify.com/insight.solutions/job-postings-monitor) — new, closed and changed postings on the career sites you watch.
- [Hiring Signals API — Open Roles & Hiring Surge by Company](https://apify.com/insight.solutions/hiring-signals-api) — one row per company per run: open roles, what opened and closed, department and seniority breakdowns, and a hiring-surge flag.
- [Remote Jobs API](https://apify.com/insight.solutions/remote-jobs-api) — RemoteOK, Remotive, We Work Remotely, Himalayas, Jobicy and more in one schema, deduplicated.
- [Shopify Products API](https://apify.com/insight.solutions/shopify-products-api) — any Shopify store's catalogue, variants, prices and stock signals.
- [WooCommerce Products API](https://apify.com/insight.solutions/woocommerce-products-api) — any WooCommerce store's catalogue, prices, variants and stock through its public Store API.
- [Shopify App Store API](https://apify.com/insight.solutions/shopify-app-store-api) — Shopify App Store listings by category, collection or developer: pricing plans, ratings and merchant reviews.
- [Shopify Store Monitor](https://apify.com/insight.solutions/shopify-store-monitor) — price drops, sales, restocks, sell-outs and new products on any Shopify store, one row per change.
- [Public Tenders API](https://apify.com/insight.solutions/public-tenders-api) — EU TED, UK Find a Tender and Contracts Finder notices by keyword, CPV code, country, stage and deadline.
- [Nonprofit & IRS 990 Lookup API](https://apify.com/insight.solutions/nonprofit-990-api) — search US nonprofits and get EIN, NTEE code and multi-year Form 990 financials.
- [OpenStreetMap Places API](https://apify.com/insight.solutions/osm-places-api) — businesses and points of interest by category and area from OpenStreetMap: name, address, coordinates, website, phone, opening hours.

**Apps & games**

- [App Store & Google Play Reviews API](https://apify.com/insight.solutions/app-reviews-api) — reviews from both stores with ratings, versions and developer replies.
- [App Store Top Charts & App Search API](https://apify.com/insight.solutions/app-charts-api) — Apple top charts by country and genre, plus app search and details.
- [App Store Keyword Rank Tracker](https://apify.com/insight.solutions/app-store-keyword-rank-tracker) — where any app ranks for any keyword on the App Store and Google Play, with rank changes and ASO suggestions.
- [Steam Reviews API](https://apify.com/insight.solutions/steam-reviews-api) — Steam reviews with playtime, helpfulness and game details.
- [Steam Game Data API](https://apify.com/insight.solutions/steam-store-stats-api) — prices, tags, review scores, live player counts and top charts.
- [Sports Scores & Schedules API](https://apify.com/insight.solutions/sports-scores-api) — scores, schedules, standings, teams and headlines for the NFL, NBA, MLB, NHL, soccer and more, no key.
- [App Store Monitor](https://apify.com/insight.solutions/app-store-monitor) — App Store and Google Play listings watched between runs: new versions with release notes, price, rating and listing changes, one row per change.

# Actor input Schema

## `mode` (type: `string`):

`place`: a city's upcoming events (luma.com/sf). `category`: the upcoming events of the calendars a category page features (luma.com/ai). `calendar`: one calendar's upcoming events. `events`: the events you link to, in full. `discover`: every city and category Luma lists, with the id and slug to use here — free rows only. Each mode reads only its own list below.

## `places` (type: `array`):

For mode `place`. One city per line: its slug (`sf`, `nyc`, `london`), its link (`https://lu.ma/sf`), its id (`discplace-…`) or its name as Luma shows it (`San Francisco`). Run mode `discover` to list every city.

## `categories` (type: `array`):

For mode `category`. Slugs (`ai`, `tech`, `climate`), links (`https://lu.ma/ai`), ids (`cat-ai`) or names (`Food & Drink`). A category is read through the calendars its page features, merged by start time.

## `calendars` (type: `array`):

For mode `calendar`. A calendar's slug (`genai-sf`), link or id (`cal-…`). A person's own calendar is read, but its name, link and picture are never included.

## `events` (type: `array`):

For mode `events`. Event links (`https://lu.ma/init-conf`), slugs (`init-conf`) or ids (`evt-…`). Each comes back in full: description, ticket types and categories included.

## `keyword` (type: `string`):

Only events whose name contains this word or phrase (whole words, any case: `AI` does not match "Fair"). Separate alternatives with commas: `AI, LLM, agents`. With details on, the description is searched too.

## `startAfter` (type: `string`):

Only events starting on or after this date. A date (`2026-11-01`) is a calendar day in each event's own timezone; a timestamp (`2026-11-01T18:00:00Z`) is an exact instant, read as UTC when it has no zone.

## `startBefore` (type: `string`):

Only events starting before this date (the day itself excluded): `startAfter` 2026-11-01 and `startBefore` 2026-12-01 is November. Same formats as `startAfter`. Because Luma lists events by start time, a city or calendar stops being read once its events pass this date.

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

`offline` keeps in-person events, `online` keeps the rest.

## `freeOnly` (type: `boolean`):

Keep only events whose registration is free.

## `includeDetails` (type: `boolean`):

Add each event's description, ticket types, categories, session, FAQ and registration-question counts and refund policy. One extra request per event, at the same price. Mode `events` always includes them.

## `descriptionFormat` (type: `string`):

`text` is clean plain text; `markdown` keeps headings, bold and italic, links, lists and images.

## `maxEventsPerSource` (type: `integer`):

The most events returned from each city, category or calendar, soonest first. Each one is a paid row; filtered-out events, duplicates and free rows do not count.

## `maxEventsTotal` (type: `integer`):

The most event rows this run returns across every source.

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

How many sources to read at the same time. Each source is still held to one request at a time, 250–600 ms apart.

## `maxRunSecs` (type: `integer`):

Stop after this many seconds. Rows already returned are kept, and a free `timeout` row names each source that was cut short or never started.

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

The capture probe read every Luma endpoint through Apify's datacenter proxy, so that is the default. A refused request is retried once from a fresh address and then becomes a free `blocked` row; switch to residential if that happens often.

## Actor input object example

```json
{
  "mode": "place",
  "places": [
    "sf"
  ],
  "categories": [],
  "calendars": [],
  "events": [],
  "keyword": "",
  "locationType": "any",
  "freeOnly": false,
  "includeDetails": false,
  "descriptionFormat": "text",
  "maxEventsPerSource": 25,
  "maxEventsTotal": 1000,
  "maxConcurrency": 3,
  "maxRunSecs": 240,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Events read from Luma's public event JSON, in one schema, plus free place, category, source and diagnostic rows. Delivered as JSON items in the default dataset.

# 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 = {
    "mode": "place",
    "places": [
        "sf"
    ],
    "categories": [],
    "calendars": [],
    "events": [],
    "locationType": "any",
    "freeOnly": false,
    "includeDetails": false,
    "descriptionFormat": "text",
    "maxEventsPerSource": 25,
    "maxEventsTotal": 1000,
    "maxConcurrency": 3,
    "maxRunSecs": 240,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("insight.solutions/luma-events-api").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 = {
    "mode": "place",
    "places": ["sf"],
    "categories": [],
    "calendars": [],
    "events": [],
    "locationType": "any",
    "freeOnly": False,
    "includeDetails": False,
    "descriptionFormat": "text",
    "maxEventsPerSource": 25,
    "maxEventsTotal": 1000,
    "maxConcurrency": 3,
    "maxRunSecs": 240,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("insight.solutions/luma-events-api").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 '{
  "mode": "place",
  "places": [
    "sf"
  ],
  "categories": [],
  "calendars": [],
  "events": [],
  "locationType": "any",
  "freeOnly": false,
  "includeDetails": false,
  "descriptionFormat": "text",
  "maxEventsPerSource": 25,
  "maxEventsTotal": 1000,
  "maxConcurrency": 3,
  "maxRunSecs": 240,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call insight.solutions/luma-events-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,insight.solutions/luma-events-api"
        }
    }
}
```

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/UehAFkNL5f1HlRgKw/builds/ar25bFc5kGCdq4ETI/openapi.json