# Eventbrite, Meetup & Luma Events Scraper by City (`m_ctim/events-scraper`) Actor

Upcoming events in any city from Eventbrite, Meetup and Luma, in one clean format: dates with time zones, venue and address, organizer, price, attendees. Duplicates across sites are merged. Filter by keyword and dates, or schedule it to get only new events.

- **URL**: https://apify.com/m_ctim/events-scraper.md
- **Developed by:** [Timothy Kelvin](https://apify.com/m_ctim) (community)
- **Categories:** Lead generation, Travel
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$20.00 / 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.

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

## Eventbrite, Meetup & Luma Events Scraper by City

For event listing sites, local newsletters, community managers and sales teams: get upcoming events in any city from Eventbrite, Meetup and Luma in one clean format, with the same event merged when it's listed on more than one site, and an only-new mode for scheduled runs.

### What you get

- **Three sites in one feed:** Eventbrite, Meetup and Luma, read in parallel, in one schema
- **Up to 10 cities per run:** type a city the way you'd say it ("Austin", "London", "Portland, Oregon"), and each site gets it in its own format
- **Times you can trust:** `startDate` and `endDate` in the event's local time with the UTC offset (`2026-11-18T18:30:00-05:00`), plus the time zone
- **Venue, organizer, price and attendees** wherever the site publishes them
- **Duplicates merged:** an event listed on two sites comes back once, and `alsoListedOn` says where else it is
- **Keyword and date filters**, and online-only events left out unless you ask for them
- **Only new events:** schedule it, and each run returns only events earlier runs didn't (skipped events aren't charged)

### Example output

Real output from a test run on 2026-11-08 (New York, keyword "tech"). A Meetup row, description shortened:

```json
{
  "rowType": "event",
  "title": "New Tech Meetup",
  "startDate": "2026-11-09T18:00:00-05:00",
  "endDate": null,
  "timezone": "America/New_York",
  "source": "meetup",
  "url": "https://www.meetup.com/ny-tech/events/317209159/",
  "venueName": "Civic Hall",
  "address": "124 E 14th St, New York, NY 10003, USA",
  "city": "New York",
  "region": "NY",
  "country": "US",
  "latitude": null,
  "longitude": null,
  "isOnline": false,
  "isCancelled": false,
  "organizer": "NY Tech Meetup",
  "organizerUrl": "https://www.meetup.com/ny-tech/",
  "isFree": false,
  "price": 20,
  "currency": "USD",
  "attendees": 6,
  "categories": [],
  "description": "**One More NY Tech Meetup Before We Close Out 2026!**\n\nWe’re wrapping up another ...",
  "imageUrl": "https://secure.meetupstatic.com/photos/event/d/4/d/0/highres_536874480.jpeg",
  "eventId": "317209159",
  "alsoListedOn": [],
  "searchLocation": "New York",
  "keyword": "tech",
  "scrapedAt": "2026-11-08T21:42:23.969Z"
}
```

An Eventbrite row from the same run has the venue's coordinates and Eventbrite's categories (`["High Tech", "Science & Technology", "Conference"]`) but no price, because Eventbrite's search results don't include one. A Luma row has the price, whether it's free, the guest count and the organizer's calendar.

`rowType` is `"event"` for events. Rows that aren't events are free: `"error"` when one site couldn't be read for a city (with the reason), and `"note"` when there's nothing to return (for example, everything was already returned by earlier runs).

### What it costs

$0.02 per event saved ($20 per 1,000). Error and note rows, events filtered out, and events skipped as already returned are free. A run with the example input (New York, all three sites) saves about 70 events, so about $1.40, and takes under a minute. To spend less, lower `maxEventsPerSource`, pick fewer sites, or set a maximum cost when you start the run: it stops there.

### Use cases

- **Event listing sites and apps:** a fresh "what's on" feed per city, without maintaining three scrapers.
- **Local newsletters:** this week's events in your city, filtered by topic and date.
- **Community and developer relations teams:** every tech meetup in the cities you care about, with organizers and attendee counts.
- **Sales and sponsorship:** find active organizers and venues, then reach them through their event pages.
- **AI agents:** one call returns clean, merged events with local times.

### Input

| Field | What it does |
|---|---|
| `locations` | Cities or areas, up to 10. Add the state or country when the name is common ("Portland, Oregon", "Manchester, UK"). Empty runs the example (New York). |
| `keyword` | Optional, e.g. `tech`, `jazz`, `startup`. Eventbrite and Meetup search for it; Luma events are kept when every word of it starts a word in the title, organizer or host names. |
| `sources` | `eventbrite`, `meetup`, `luma`, or any mix. Default: all three. |
| `maxEventsPerSource` | Events to read from each site per city, 1 to 200. Default 40. |
| `dateFrom`, `dateTo` | Optional dates (YYYY-MM-DD): events still on from `dateFrom`, starting on or before `dateTo`. |
| `includeOnlineEvents` | Also keep online-only events. Default off. |
| `onlyNew` | Skip events earlier runs returned. For scheduled runs. |
| `seenListName` | The name of the "already returned" list. Give each schedule or client its own. |

Every tech event in two cities next month:

```json
{
  "locations": ["Austin", "Denver"],
  "keyword": "tech",
  "dateFrom": "2026-12-01",
  "dateTo": "2026-12-31"
}
```

A weekly "new events" feed for one city (schedule it):

```json
{
  "locations": ["London"],
  "onlyNew": true,
  "seenListName": "london-weekly"
}
```

### How much each site gives

- **Eventbrite:** its city search, 20 events a page, up to 200 per city. Ticket prices aren't in the search results, so `price` and `isFree` are empty for Eventbrite rows.
- **Meetup:** the first page of its event search, about 20 to 30 events per city with a keyword. Without a keyword Meetup shows its recommended events for the city instead, about 10 to 15. Meetup doesn't publish venue coordinates or end times there.
- **Luma:** its city pages, about 90 cities worldwide, with their featured upcoming events (about 20 each). A city more than 75 km from a Luma city gets a free note row saying so.

When a site matches a place to somewhere else (for example a small town it doesn't know), that site is skipped for that place with a free error row, rather than returning events from the wrong city. Brooklyn and other parts of a city are searched as the city when a site does that itself.

### Related tools

- [Website Gap Finder](https://apify.com/m_ctim/website-gap-finder): local businesses from Google Maps with phones, emails and websites, for venues and sponsors near your events
- [Blog & RSS Feed Monitor](https://apify.com/m_ctim/rss-feed-tracker): new posts from any feed, for organizers and venues that publish their events by RSS

### Notes

- It reads the public pages anyone can open, with an identifying User-Agent and at most one request every 1.5 seconds per site.
- Event details belong to their organizers. When you show them, link to the event page (`url`).
- Questions or a city that doesn't work? Open an issue on the Issues tab.

# Actor input Schema

## `locations` (type: `array`):

Cities or areas to search, up to 10 per run. Add the country or state when the name is common, e.g. "Portland, Oregon" or "Manchester, UK". Empty runs the example (New York).

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

Only events about this, e.g. "tech", "jazz" or "startup". Eventbrite and Meetup search for it themselves; Luma's city pages have no search, so Luma events are kept when every word starts a word in the title, organizer or host names. Up to 80 characters.

## `sources` (type: `array`):

Which sites to read. Leave all three for the widest list; the same event listed on two sites is merged into one row.

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

How many events to read from each site for each city, from 1 to 200. Eventbrite has 20 a page; Meetup's search shows about 20 to 30 and Luma's city pages about 20, so more than that only adds Eventbrite events.

## `dateFrom` (type: `string`):

Only events that are still on from this date (YYYY-MM-DD).

## `dateTo` (type: `string`):

Only events that start on or before this date (YYYY-MM-DD).

## `includeOnlineEvents` (type: `boolean`):

City searches can include online-only events. Off keeps only in-person and hybrid events.

## `onlyNew` (type: `boolean`):

For scheduled runs: skip events earlier runs already returned, so each run brings only new ones. Skipped events aren't charged. The list is kept in a named key-value store in your account.

## `seenListName` (type: `string`):

Give each schedule or client its own list so their events don't hide each other's. 3 to 63 characters: lowercase letters, digits and hyphens.

## Actor input object example

```json
{
  "locations": [
    "New York",
    "London"
  ],
  "keyword": "tech",
  "sources": [
    "eventbrite",
    "meetup",
    "luma"
  ],
  "maxEventsPerSource": 40,
  "includeOnlineEvents": false,
  "onlyNew": false,
  "seenListName": "events-scraper-seen"
}
```

# Actor output Schema

## `results` (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 = {
    "locations": [
        "New York",
        "London"
    ],
    "keyword": "tech"
};

// Run the Actor and wait for it to finish
const run = await client.actor("m_ctim/events-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 = {
    "locations": [
        "New York",
        "London",
    ],
    "keyword": "tech",
}

# Run the Actor and wait for it to finish
run = client.actor("m_ctim/events-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 '{
  "locations": [
    "New York",
    "London"
  ],
  "keyword": "tech"
}' |
apify call m_ctim/events-scraper --silent --output-dataset

```

## MCP server setup

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