# Luma City Discover (`scrape_scaler/luma-event-scraper`) Actor

Discover public Luma events by city and category. Returns venue, address, dates, ticketing, and geocodes missing coordinates.

- **URL**: https://apify.com/scrape\_scaler/luma-event-scraper.md
- **Developed by:** [Creative Scraps](https://apify.com/scrape_scaler) (community)
- **Stats:** 3 total users, 2 monthly users, 92.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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 City Discover

Discover **public Luma (lu.ma) events** by metro and date range. Uses Luma’s public **place** discover API over HTTP (no browser) and returns normalized JSON for calendars, newsletters, research, and automation pipelines.

Categories are **not** used as scrape filters. Assign categories later in your ingestion pipeline (e.g. n8n). Any category/tag metadata Luma returns on an event is still mapped into the output when present.

### How it works

1. Resolves your city name (or `lat`/`lng`) to a metro center and a Luma place slug when available (e.g. `nyc`, `la`, `sf`, `london`).
2. Fetches that **city place feed** with cursor pagination (`slug=<place>` only — no category loop).
3. Keeps events inside your date window and within `radiusKm` of the metro center.
4. Writes public listings only — name, URL, venue/address, coordinates when Luma provides them, ticketing, organizer, and optional `categories` / `tags` from Luma.

### Input

| Field | Required | Description |
|-------|----------|-------------|
| `city` | One of `city` / `cities` / `lat`+`lng` | Metro name, e.g. `New York`, `Miami`, `London` |
| `cities` | Same | Optional list of cities (overrides single `city` when set) |
| `categories` | No | **Deprecated / ignored.** Kept for backward compatibility only |
| `startDate` / `endDate` | No | `YYYY-MM-DD` (default: today → +14 days UTC) |
| `radiusKm` | No | Keep events near metro center (default `80`) |
| `maxItems` | No | Stop after N unique events |
| `maxPages` | No | Pagination cap per place feed (default `8`) |
| `lat` / `lng` | No | Coordinate override; place slug still required for discovery |
| `proxyConfiguration` | No | **Residential Apify Proxy recommended** |

### Output

Each dataset item includes:

- Identity: `id`, `name`, `url` / `lumaUrl`
- Schedule: `startAt`, `endAt`, `timezone`
- Place: `location.venue`, `address`, `fullAddress`, `city`, `region`, `country`, `latitude`, `longitude` (when Luma returns them)
- Meta: `category`, `categories`, `tags`, `eventType`, `coverImageUrl`, `organizer`, `ticketing`, `guestCount`, `isOnline`, `featuredCity`

#### Example output

```json
{
  "source": "luma",
  "id": "evt-f8Rkzv6IvfH0F13",
  "name": "IN GOOD FORM",
  "lumaUrl": "https://lu.ma/carpart-ojnu",
  "url": "https://lu.ma/carpart-ojnu",
  "description": "",
  "startAt": "2026-09-13T14:00:00.000Z",
  "endAt": "2026-09-13T20:00:00.000Z",
  "timezone": "America/New_York",
  "coverImageUrl": "https://images.lumacdn.com/uploads/gj/ac0e5f94-4dd9-40d0-a099-2753067225a2.png",
  "image_url": "https://images.lumacdn.com/uploads/gj/ac0e5f94-4dd9-40d0-a099-2753067225a2.png",
  "category": "car part time",
  "categories": [],
  "tags": [],
  "eventType": "independent",
  "location": {
    "venue": "car part time",
    "fullAddress": "car part time, 904 Grand St, Brooklyn, NY 11206, USA",
    "address": "904 Grand St, Brooklyn",
    "city": "Brooklyn",
    "region": "New York",
    "country": "United States",
    "latitude": 40.7124558,
    "longitude": -73.9379107,
    "locationType": "offline",
    "virtualUrl": null,
    "placeId": "ChIJo07-ptNZwokRpBsALZY-ing"
  },
  "organizer": {
    "name": "car part time",
    "calendarName": "car part time"
  },
  "guestCount": 0,
  "visibility": "public",
  "city": "New York",
  "citySlug": "nyc",
  "featuredCity": { "name": "New York", "slug": "nyc" },
  "isOnline": false,
  "ticketing": {
    "isFree": true,
    "priceCents": null,
    "currency": null,
    "isSoldOut": false
  }
}
```

### Use cases

- City “what’s on” calendars and weekly digests
- Full metro event pulls before downstream category assignment
- Venue / attendance signals for local community mapping
- Pipelines that need structured Luma listings without a browser scraper

### Notes

- Only **public** discover listings are returned.
- Coordinates are included **when Luma provides them**. This Actor does **not** geocode missing lat/lng — use venue/address in your own pipeline if needed.
- Discovery requires a Luma place slug (`nyc`, `la`, `sf`, …). Metros without a place page are skipped (no category-feed fallback).
- Event `description` is empty on list responses (discover API does not include full body text).
- Residential Apify Proxy is recommended for reliability.

### Tips

- Cheap smoke test: `city: "Los Angeles"`, `maxItems: 20`, `maxPages: 2`, omit `categories`
- Date filter is applied client-side after the place feed is fetched

# Actor input Schema

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

Metro name (e.g. New York, Miami, London). Aliases like NYC, LA, SF also work. Provide city, cities, or lat+lng.

## `cities` (type: `array`):

Optional list of metros. When set, overrides the single city field — one discover pass is run per city in a single Actor run.

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

Deprecated. No longer used for discover filtering. Discovery always uses the city/place feed. Any category or tag fields Luma returns on each event are still mapped into the output for downstream assignment.

## `lat` (type: `number`):

Optional metro latitude. Use with lng when city is omitted or not in the built-in map. Place slug still required for discovery.

## `lng` (type: `number`):

Optional metro longitude. Use with lat when city is omitted or not in the built-in map. Place slug still required for discovery.

## `startDate` (type: `string`):

Include events starting on or after this date (YYYY-MM-DD). Defaults to today (UTC).

## `endDate` (type: `string`):

Include events starting on or before this date (YYYY-MM-DD). Defaults to +14 days (UTC).

## `radiusKm` (type: `number`):

Keep events within this distance of the metro center (default 80).

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

Stop after this many unique events. Omit for no hard cap (still bounded by maxPages).

## `maxPages` (type: `integer`):

Pagination cap per city place discover feed (default 8).

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

Residential Apify Proxy is recommended for reliable discover API access.

## Actor input object example

```json
{
  "city": "New York",
  "cities": [
    "New York",
    "San Francisco"
  ],
  "lat": 40.7128,
  "lng": -74.006,
  "startDate": "2026-09-20",
  "endDate": "2026-10-04",
  "radiusKm": 80,
  "maxItems": 50,
  "maxPages": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `events` (type: `string`):

No description

## `run` (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": "New York",
    "radiusKm": 80,
    "maxItems": 50,
    "maxPages": 8
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrape_scaler/luma-event-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "city": "New York",
    "radiusKm": 80,
    "maxItems": 50,
    "maxPages": 8,
}

# Run the Actor and wait for it to finish
run = client.actor("scrape_scaler/luma-event-scraper").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": "New York",
  "radiusKm": 80,
  "maxItems": 50,
  "maxPages": 8
}' |
apify call scrape_scaler/luma-event-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrape_scaler/luma-event-scraper"
        }
    }
}
```

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/R924PWDvk7YqWxFuD/builds/XVodQEZ0YNfQPNgvl/openapi.json