# Eventbrite, Meetup & Luma Events Scraper by City (`alexmorain/eventbrite-luma-meetup-scraper`) Actor

Scrape Eventbrite, Meetup and Luma events around any city or coordinates into one table: dates, venue, price, organizer, website and socials. Gets past Eventbrite's 1,000 result wall: 26,000 New York events in 5 minutes. Real radius, new-only alerts, webhook, CSV export.

- **URL**: https://apify.com/alexmorain/eventbrite-luma-meetup-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** Lead generation, Social media, Automation
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 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

### Eventbrite, Meetup and Luma Events Scraper: every event around a city, in one table

This actor returns **the events around a city or a pair of coordinates** from [Eventbrite](https://www.eventbrite.com), [Meetup](https://www.meetup.com) and [Luma](https://luma.com), in one schema: title, start and end in UTC and in local time, venue, address, coordinates, **price range**, ticket status, category, and the **organizer with its website and social profiles**. Type a place name, or give coordinates and a radius. You can also paste event, organizer, group or calendar URLs. **Facebook events** come as a fourth source when you tick it in **Sources**.

It works as an **Eventbrite API, Meetup API and Luma API alternative** in a single call. No API key, no login, no browser: plain HTTP on the JSON services the three websites call themselves. Facebook, the optional fourth source, is read through a third-party data provider, with no Facebook account of yours. Results land in a dataset you can export as JSON, CSV, Excel or XML, or read through the Apify API from Python, JavaScript or cURL.

The three platforms hide most of their events behind a cap: one Eventbrite search stops at 1,000 results, one Meetup search at about 600, Luma's city page shows about 70 events in New York. This actor cuts each search into slices the platform serves in full, reads the organizer pages the feeds leave out, and removes duplicates before you are charged.

#### What one run returns for New York

Measured on the Apify platform on 17 and 18 November 2026, New York, 25 km radius, 30 days, the three sources in one run:

| Source | Events delivered | One plain search on the platform |
|---|---|---|
| Eventbrite | 16,556 | about 975 |
| Meetup | 8,538 | about 575 |
| Luma | 1,593 | about 70 (the city page) |
| **Total, one run** | **26,687** | |

The run took **5.5 minutes** on 512 MB and cost **$0.15 of platform usage**. What you pay is per event, see [the pricing section](#how-much-does-it-cost-to-scrape-events). The same columns hold the three sources, with a `source` field to tell them apart.

### Why use this events scraper

- **Lead generation.** Every event has an organizer, and most organizers show a website, a Facebook page or a Twitter account. Find who runs events in a city and in which niche, then contact them. No email: none of the three platforms serves one, and the actor does not guess.
- **Event aggregators and local guides.** Fill a "what's on this week" page for a city: real coordinates, local start times, prices, images.
- **Venues, brands and sponsors.** See which organizers are active around you, how often they host, what they charge and how many people sign up (Meetup and Luma give the RSVP count).
- **Market research.** Count events by category, day, price or organizer across a metropolitan area, and compare cities with one schema.
- **Monitoring.** Schedule a daily run in new-events-only mode, with a webhook message at the end.

On top of a plain export you get a **real radius** (`distanceKm` on every row, events outside it are free), **one schema** for three platforms (57 columns, ISO dates, prices in currency units, full URLs for social profiles), **filters on the actor's side** (keywords, categories, free or paid, in person or online, dates), **new events only**, a webhook, and a coverage record per search. Events that are filtered out, outside the radius, duplicated or already delivered are never charged.

As an Apify actor it runs on a schedule, from the API, or from Make, Zapier, n8n and other integrations, with proxy rotation and run monitoring included.

### How to scrape Eventbrite events by city

Eventbrite shows "10,000" events for New York, then stops silently. One search serves 50 pages of 20 and the page after is empty, so a plain read, from the website or from a scraper that pages through one URL, ends at about 1,000 results. Over 30 days in New York that read returns about 975 events. The actor reads the same service differently:

1. It asks for **one day at a time** (`date_range` of one local day), over the area of a box that encloses your circle.
2. When a day announces 950 events or more, it reads the day, then cuts it by **category** (Eventbrite's 20 categories), and cuts a category that is still too big by **free and paid**.
3. A day of 150 events or more is also read a second time by price, because the page order shifts and pages overlap. On a test day in New York this found 5% more events.
4. Everything is merged on the event id, so an event that runs over several days or shows up on two pages is returned once.

Over 30 days in New York this returns **13,500 to 16,500 events** depending on the day of the run (16,556 in the three source run above). The status of your run shows what Eventbrite announced against what was read:

```
eventbrite | New York, NY: fetched 2381 of 2841 announced, delivered 706, filtered 1675 (...)
```

`fetched X of Y announced` is the honest number. **About 7% of what Eventbrite announces is never served**, even with seven passes over the same day, so `fetched` stays below `announced` on every run. An event that lasts three days is announced three times and read once, which widens the gap a little. A slice still above the wall after the category and price cuts is named in the notes of the run.

Two things to know about Eventbrite:

- **No online events in a search by place.** Eventbrite online events have no venue and no position, and Eventbrite does not return them for an area. With a location the actor returns no online event from Eventbrite and says so in the notes. An organizer URL (`eventbrite.com/o/...`) returns that organizer's online events, as listed on its page.
- **Description and organizer details need Include details.** The list gives the title, dates, venue, price, categories, image and the organizer's name, followers and links. Turn on **Include details** to add the full description (100% of events in our tests) and the organizer page: Instagram, the verified badge and the full bio.

Organizer fields on Eventbrite, from the list alone, over a New York run: followers 98%, website 58%, Facebook 36%, Twitter 23%.

### How to scrape Meetup events without an API key

Meetup's official API needs a Pro subscription. The website itself uses a GraphQL service that needs no account and no key, and the actor reads that one. A Meetup area search returns about 600 events at most, whatever the area holds: the page after is empty, the total it announces is just the size of the page, and nothing says the list was cut. In New York a plain search returns about 575 events.

The actor reads **one day at a time**, which stays under the cap, then reads the **page of every group** it saw in the area (1,115 groups for New York), because Meetup's recommended feed leaves out part of the events those groups host. Each group page is read up to the end of your window, never without a limit: recurring series would otherwise be projected for years.

| Meetup, New York, 25 km, 45 days (17 November 2026) | Events |
|---|---|
| One plain search | about 575 |
| This actor, day by day then the groups of the area | **11,461** |

That run made 1,190 requests in 5 and a half minutes, with no refusal.

What Meetup adds that the others do not: the **group** (name, URL, **number of members**, **average rating and number of ratings**, description, Facebook, Twitter, Instagram, LinkedIn and TikTok when the group lists them), the **hosts** (name, id and profile link), the **RSVP count**, the **waitlist**, and the **capacity** when the organizer sets one. The description comes with every event: Meetup's lists already carry it, so Meetup events are always complete and always billed as plain events.

Meetup's feed is empty beyond about 10 weeks, so without an end date the actor reads 70 days. A later end date is accepted: the group pages cover what the feed does not.

### Luma events API alternative

Luma's API is meant for the owners of a calendar, and its city page shows about 70 events for New York. The actor reads Luma's discovery feed for the coordinates of your place, then **the public calendars of the organizers** it finds there (897 calendars in New York), and returns about **2,000 events within 25 km** (2,022 in a test run, 1,593 in the 30 day window of the three source run, because Luma lists upcoming events and the window cuts them).

Luma's feed is a metropolitan bucket, not a radius, so the actor computes the distance itself and drops what is outside. Private calendars are skipped and counted. The description, categories, the price range across ticket types and the capacity come with **Include details**, which reads one event page per event.

Luma's strength is the **organizer**: its calendar, its LinkedIn, Instagram, X, TikTok and YouTube handles, a verified flag, and each **host** with the same links.

### Facebook events by city

Tick **Facebook** in **Sources** and the actor reads the public events of the Facebook city page of each location you typed: it finds the city page closest to your place (for example New York, Paris or Austin, TX), then reads its events feed to the end, plus the "this week" and "next week" feeds when your window starts within two weeks, because the main feed leaves out a good part of the coming days. Past events are skipped, duplicates are removed before you are charged.

Measured on November 19, 2026: the New York city page gives **3,230 upcoming events** in one run (about 20 minutes, the Facebook feed is slow to page through), Austin, TX more than 500. Type the city the way people write it (`New York, NY`, `Austin, TX`, `San Francisco`): the actor looks the name up on Facebook and keeps the city page of that name nearest to your place.

What a Facebook row holds without details: title, date and local time, venue name, city, country, online or in person, the **going count** in `attendeeCount`, the cover image, and the position of the **city centre** (`locationApproximate: true`), so the radius does not cut a Facebook city page. With **Include details** the actor reads each event page: exact position and street address, postal code, the full description, the **organizer page** and the **host pages**, and the verified badge. An event URL (`facebook.com/events/<id>/`) is always read with its details.

Facebook opens to every account on December 4, 2026; before that date a run that ticks it gets a note and no Facebook rows. Facebook is off unless you tick it, so a run that did not ask for it never pays for it. Facebook lists no price and no category: with **Price** or **Categories** set, Facebook is skipped with a note and the other sources are read. It needs a place name, not latitude and longitude. When your filters keep very few of the events read (a rare keyword, a narrow window), the reading stops early with the stop value `low-yield` rather than reading thousands of events you would not keep.

### What data can the events scraper extract?

Every row is one event. The columns are the same for the three sources. A field a source does not provide comes back as `null`, so every row has the same shape. The last four columns say which source fills each field (Facebook only when you add it to **Sources**): **yes**, **details** (only with Include details), **some** (when the source has it), **no**.

| Field | Type | Description | Eventbrite | Meetup | Luma | Facebook |
|---|---|---|---|---|---|---|
| `source` | string | `luma`, `eventbrite` or `meetup` | yes | yes | yes | yes |
| `eventId` | string | Id in the source. With `source`, a stable key to deduplicate on | yes | yes | yes | yes |
| `url` | string | Public event page | yes | yes | yes | yes |
| `title` | string | Event title | yes | yes | yes | yes |
| `description` | string | Full description as plain text. Eventbrite and Luma: with Include details; Meetup: always | details | yes | details | details |
| `startAt` | string | Start, ISO 8601 in UTC | yes | yes | yes | yes |
| `endAt` | string | End, ISO 8601 in UTC | yes | yes | yes | no |
| `startLocal` | string | Start in the venue's time zone, with its offset | yes | yes | yes | yes |
| `endLocal` | string | End in the venue's time zone, with its offset | yes | yes | yes | no |
| `timezone` | string | IANA time zone | yes | yes | yes | no |
| `isOnline` | boolean | Online only. Hybrid events have a venue and are `false` | yes | yes | yes | yes |
| `attendanceMode` | string | `in-person`, `online` or `hybrid` | yes | yes | yes | yes |
| `status` | string | `scheduled` or `cancelled` | yes | yes | yes | yes |
| `venueName` | string | Venue name | yes | yes | yes | yes |
| `address` | string | Full address as the source writes it | yes | yes | yes | some |
| `city` | string | City | yes | yes | yes | details |
| `region` | string | State or region | yes | yes | yes | details |
| `country` | string | Country name | yes | yes | yes | yes |
| `countryCode` | string | ISO country code | yes | yes | yes | yes |
| `postalCode` | string | Postal code | yes | yes | no | details |
| `latitude` | number | Venue latitude (`null` online) | yes | yes | yes | yes |
| `longitude` | number | Venue longitude (`null` online) | yes | yes | yes | yes |
| `locationApproximate` | boolean | `true` when the exact address is hidden or missing and the position is the centre of the city or the place of the organizer (Luma, Meetup) | no | yes | yes | yes |
| `distanceKm` | number | Straight-line distance in km from the centre of the search | yes | yes | yes | yes |
| `isFree` | boolean | Free to attend | yes | yes | yes | no |
| `priceMin` | number | Lowest ticket price, in currency units | yes | yes | yes | no |
| `priceMax` | number | Highest ticket price, in currency units | yes | yes | yes | no |
| `currency` | string | ISO 4217 code, uppercase | yes | yes | yes | no |
| `isSoldOut` | boolean | No ticket left (Meetup: when the capacity is set and reached) | yes | some | yes | no |
| `spotsRemaining` | number | Spots left (Luma; Meetup when a capacity is set) | no | some | yes | no |
| `capacity` | number | Capacity: Meetup when the organizer sets a limit, Luma with Include details when every ticket type states one, not served by Eventbrite | no | some | details | no |
| `attendeeCount` | number | Registered guests (RSVP yes on Meetup) | no | yes | yes | yes |
| `waitlist` | boolean | Waitlist is active | no | yes | yes | no |
| `requiresApproval` | boolean | The host approves registrations | no | no | yes | no |
| `categories` | array | Categories as the source labels them | yes | yes | details | no |
| `category` | string | Unified category, the list is in the input examples | yes | yes | yes | no |
| `tags` | array | Tags or topics of the event, the organizer or the group | yes | yes | some | no |
| `imageUrl` | string | Cover image | yes | yes | yes | yes |
| `organizerName` | string | Organizer: the group (Meetup), the calendar (Luma), the organizer profile (Eventbrite) | yes | yes | yes | details |
| `organizerId` | string | Organizer id in the source | yes | yes | yes | details |
| `organizerUrl` | string | Organizer page | yes | yes | yes | details |
| `organizerWebsite` | string | Organizer website | yes | some | yes | no |
| `organizerLinkedin` | string | LinkedIn, full URL | no | some | yes | no |
| `organizerInstagram` | string | Instagram, full URL | details | some | yes | no |
| `organizerTwitter` | string | X (Twitter), full URL | yes | some | yes | no |
| `organizerFacebook` | string | Facebook, full URL | yes | some | no | details |
| `organizerTiktok` | string | TikTok, full URL | no | some | yes | no |
| `organizerYoutube` | string | YouTube, full URL | no | no | yes | no |
| `organizerFollowers` | number | Followers of the organizer profile | yes | no | no | no |
| `organizerMembers` | number | Members of the group | no | yes | no | no |
| `organizerRating` | number | Average rating of the group's events, 0 to 5 | no | yes | no | no |
| `organizerReviewCount` | number | Number of ratings behind it | no | yes | no | no |
| `organizerVerified` | boolean | Verified badge | details | no | yes | details |
| `organizerDescription` | string | Short description or bio of the organizer | yes | yes | yes | no |
| `hosts` | array | Hosts: name, id, URL (Meetup) and, on Luma, their links and verified flag | no | yes | yes | details |
| `searchLabel` | string | The place or URL that found the event | yes | yes | yes | yes |
| `scrapedAt` | string | When the run read it, UTC | yes | yes | yes | yes |

Notes on the table: `organizerWebsite` and the social fields on Meetup are the links the group lists. On Eventbrite, `organizerWebsite` is filled for about 58% of events, Facebook 36%, Twitter 23% and followers 98% (New York). The Eventbrite description and the organizer page need **Include details**.

#### Example rows

The Eventbrite row is a real event of the New York area read on 18 November 2026, shortened. The Luma row is a real event of Paris, shortened. A Meetup row has the same columns, with `organizerMembers`, `organizerRating`, `organizerReviewCount`, `attendeeCount`, a `description` and `hosts` with a profile link filled.

**Eventbrite**

```json
{
  "source": "eventbrite",
  "eventId": "1994434242508",
  "url": "https://www.eventbrite.com/e/friday-night-lights-at-mama-taco-everyone-free-b4-12am-wrsvp-tickets-1994434242508",
  "title": "Friday Night Lights at Mama Taco Everyone FREE B4 12am w/RSVP",
  "description": null,
  "startAt": "2026-11-21T01:00:00Z",
  "startLocal": "2026-11-20T20:00:00-05:00",
  "attendanceMode": "in-person",
  "status": "scheduled",
  "venueName": "MAMATACO",
  "address": "880 Flushing Avenue, Brooklyn, NY 11206",
  "city": "Brooklyn",
  "region": "NY",
  "countryCode": "US",
  "postalCode": "11206",
  "latitude": 40.701824,
  "longitude": -73.93664799999999,
  "distanceKm": 6.0,
  "isFree": false,
  "priceMin": 0.0,
  "priceMax": 55.2,
  "currency": "USD",
  "isSoldOut": false,
  "categories": ["Hip Hop / Rap", "Music"],
  "category": "music",
  "tags": ["Party or Social Gathering", "Reggae", "Afrobeats", "Afterwork"],
  "organizerName": "JiggyTime Ent",
  "organizerId": "5494940201",
  "organizerUrl": "https://www.eventbrite.com/o/jiggytime-ent-5494940201",
  "organizerWebsite": "https://jiggytimeevents.com/",
  "organizerTwitter": "https://x.com/JIGGYTIMEJAY",
  "organizerFacebook": "https://www.facebook.com/JiggyTimeFanPage",
  "organizerFollowers": 3816,
  "organizerDescription": "Click here to subscribe to our text messages.",
  "hosts": [],
  "searchLabel": "New York, NY",
  "scrapedAt": "2026-11-18T09:00:00Z"
}
```

The `null` fields are left out above to keep it short. With **Include details**, `description` holds the full text, and `organizerInstagram`, `organizerVerified` and the full `organizerDescription` are filled when the organizer page has them.

**Luma** (shortened)

```json
{
  "source": "luma",
  "eventId": "evt-cpTwVOdL4SzqlHR",
  "title": "🏡 BOOST-CAMP #16 - Être robuste",
  "startLocal": "2026-11-18T09:00:00+01:00",
  "venueName": "Climate House Paris Sentier",
  "city": "Paris",
  "distanceKm": 1.6,
  "isFree": false,
  "priceMin": 18.0,
  "priceMax": 30.0,
  "currency": "EUR",
  "spotsRemaining": 31,
  "requiresApproval": true,
  "organizerName": "🏡 - Evénements @ Climate House",
  "organizerUrl": "https://luma.com/climate.house",
  "organizerLinkedin": "https://www.linkedin.com/in/climate-house-ch",
  "organizerInstagram": "https://www.instagram.com/climatehouse_paris",
  "hosts": [{"name": "Climate House", "url": "https://luma.com/user/CLIMATEHOUSE", "isVerified": false}]
}
```

#### Dates, time zones and the radius

- `startAt` and `endAt` are UTC. `startLocal` and `endLocal` are the time on the wall of the venue, with its offset, and `timezone` is the IANA zone. Filter on the local fields for "Friday evening".
- **A date without a time in the input is a local day**: `startDate: "2026-12-05"` keeps events whose local start day is the 5th, wherever the event is. A date with a time (`2026-12-05T18:00:00Z`) is an exact instant. Relative dates work too: `today`, `7 days`.
- **The radius is a real radius.** The platforms return a metropolitan bucket or a box. The actor computes the straight-line distance from your centre to each venue (`distanceKm`) and keeps what is within the radius. Default 25 km, from 1 to 500.
- **Hidden addresses.** Luma and Meetup hide some venues until you RSVP. When the exact address is hidden, the event is placed at the centre of its city, or at the place of its organizer, and `locationApproximate` is `true`. An event that cannot be placed at all is left out and counted as "no location".
- **Online events.** On Luma and Meetup an online event is kept only if its organizer (calendar or group) sits within the radius. Otherwise it would be a webinar from anywhere in the world. Eventbrite online events are not returned for a place (see above). On a URL you gave, nothing is left out.

### How to scrape events, step by step

1. Open the actor and type a place in **Locations**, for example `Austin, TX`. Add a state or a country for a name that exists in several places (`Paris, Texas`, `London, UK`). Or fill **Latitude** and **Longitude**.
2. Set the **Radius** (25 km by default) and the **Sources** you want. Empty means all three.
3. Optional: set **Starts on or after** and **Starts on or before**, **Keywords**, **Categories**, **Price** or **Attendance**.
4. Set **Max events** to the number you need, or 0 for everything in the window. A big city holds tens of thousands of events.
5. Click **Start**. Download the results as JSON, CSV or Excel, or read them from the API.

#### Input examples

An example of each use. See the Input tab for every option.

Without an end date, Eventbrite and Meetup are read 70 days ahead (Meetup's feed is empty beyond 10 weeks), and Luma lists everything upcoming. `{"locations": ["Austin, TX"], "maxItems": 0}` is a complete input.

**Coordinates, one source, a 10 km radius**

```json
{
  "latitude": 48.8566,
  "longitude": 2.3522,
  "radiusKm": 10,
  "sources": ["eventbrite"],
  "startDate": "2026-12-05",
  "endDate": "2026-12-07",
  "maxItems": 0
}
```

**Keywords: the events that talk about it**

```json
{
  "locations": ["London, UK"],
  "keywords": ["python", "data engineering"],
  "startDate": "today",
  "endDate": "30 days",
  "maxItems": 0
}
```

On Eventbrite each keyword is a full-text search for the exact word (one search per word and day), on Meetup a search per word and day. Both find far more than the plain feed, because the platform applies the keyword before its cap. On Luma the keyword is matched on the title, organizer, venue, categories and tags, and on the description with **Include details**.

**Categories and free events**

```json
{
  "locations": ["Berlin, Germany"],
  "categories": ["tech", "startups"],
  "priceFilter": "free",
  "eventType": "in-person"
}
```

The unified categories are `tech`, `ai`, `crypto`, `business`, `startups`, `science`, `climate`, `health-wellness`, `fitness-sports`, `arts-culture`, `music`, `food-drink`, `education`, `community`, `social`, `family`, `travel-outdoor`, `nightlife`, `religion` and `charity`. Each source maps them to its own categories: Eventbrite and Meetup to their own 20, Luma to its category feeds (tech, ai, crypto, climate, health-wellness, fitness-sports, arts-culture, food-drink, family). A category with no equivalent on a source returns nothing there, and the notes say so. Fine categories such as `ai`, `crypto` or `startups` read the broader category of the source (for example Science and Tech on Eventbrite), so the result is wider than the word. Organizer pages are not read when a category is set.

**Start URLs: an organizer, a group, a calendar or one event**

```json
{
  "startUrls": [
    "https://www.eventbrite.com/o/art-hearts-fashion-3598289939",
    "https://www.meetup.com/boardgame-icebreakers/",
    "https://luma.com/climate.house",
    "https://lu.ma/hp087drj"
  ],
  "includeDetails": true
}
```

- **Eventbrite**: an event page (`/e/...-tickets-<id>`, any Eventbrite domain: .com, .co.uk, .fr, .de) or an organizer page (`/o/<name>-<id>`). The organizer page lists its upcoming events, online ones included, as the page shows them. If the page lists fewer than the organizer has, a note says how many are missing.
- **Meetup**: a group page (`meetup.com/<group>/`), read up to 180 days ahead unless you set an end date, or an event page (`meetup.com/<group>/events/<id>/`).
- **Facebook**: an event page (`facebook.com/events/<id>/`, always read with its details) or a city page (`facebook.com/events/explore/<city>/<id>/`). Facebook pages of organizers are not read in this version.
- **Luma**: an event, an organizer calendar, a city page such as `luma.com/nyc` (read around its centre with your radius) or a category page. `lu.ma` short links work.

URLs are never filtered by distance, only by the common filters (dates, keywords, categories, price).

**New events only, with a webhook**

```json
{
  "locations": ["New York, NY"],
  "radiusKm": 25,
  "newOnly": true,
  "registryKey": "nyc-weekly-watch",
  "webhookUrl": "https://hooks.slack.com/services/XXX/YYY/ZZZ",
  "maxItems": 0
}
```

#### Include details

**Include details** fetches more for each delivered event:

| Source | What it adds | Billed as |
|---|---|---|
| Eventbrite | The full description as text, and the organizer page: Instagram, verified badge, full bio. One page per organizer for the whole run. | Detailed event |
| Luma | The event page: full description, categories, price range across ticket types, capacity | Detailed event |
| Meetup | Nothing: its lists already carry all of this | Event |
| Facebook | The event page: exact position and address, postal code, description, organizer page, host pages, verified badge | Detailed Facebook event |

An event whose detail could not be fetched (a failed request, an organizer without a page) is delivered as it is and billed as a plain event. If a source keeps failing, the details are switched off for the rest of the run and a warning says so.

### New events alert and webhook

Set **New events only (watch)** and schedule the run. The actor remembers what it already delivered for this watch and charges only events it has not delivered before. It still reads everything every time, so an event that shows up late, or an event whose date you could not know in advance, is never missed.

- The memory is a named key-value store of your account (`events-scraper-monitor`), one record per watch.
- Without a name, a watch is defined by its locations, radius, sources, URLs, keywords, categories, attendance and price, **not by the dates**: you can move the window forward from one run to the next and keep the same memory. Change any of the others and you start a new watch.
- Set **Watch name** to share one memory between several schedules, or to keep two schedules apart.
- The first run of a watch returns everything in the window. The next ones return what is new.

Set **Webhook URL** (a Slack, Discord or any HTTP endpoint) and the actor POSTs a JSON summary when the run ends. The URL is stored as a secret and never written to the log. The payload:

```json
{
  "actor": "alexmorain/eventbrite-luma-meetup-scraper",
  "runId": "HG7ml...",
  "datasetId": "WkzbQ...",
  "mode": "new",
  "status": "succeeded",
  "events": 143,
  "searches": [
    {"source": "eventbrite", "target": "New York, NY", "fetched": 9120, "delivered": 143, "stop": "complete"}
  ],
  "chargeLimitReached": false
}
```

`actor` is the full name of the actor that ran, read from the run. `status` is `succeeded`, `partial` (a source refused part of its requests, or a search failed) or `failed`. `stop` says why the reading of a search ended: `complete` (read to the end), `max-items` (your **Max events** was reached), `capped` (your spending limit was reached), `refused` (the platform kept refusing the requests: partial results), `error` (a page that does not exist, an access denied), `unavailable` (the source cannot run), `skipped` (Facebook with a price or category filter, or with coordinates only), `low-yield` (Facebook stopped because your filters keep too few of the events read) or `free-limit` (the daily Facebook limit of the free Apify plan was reached).

### What the status of a run tells you

Every run writes one line per source and per search, in the log and in the status message:

```
luma | New York, NY: 2022 events within 25 km (3611 read, incl. 2264 from organizer calendars)
```

That is the events delivered, the radius, the events read before the filters, and how many came from organizer pages (Luma calendars, Meetup group pages: `meetup | ... (... read, incl. N from organizer group pages)`). A line that ends with a note says the run was cut short: your limit, your spending limit, or a refusal by the platform (partial results).

The run's key-value store holds a `COVERAGE` record, one entry per source and search: `announced` (Eventbrite only), `fetched`, `delivered`, `filtered` by reason (`distance`, `date`, `keyword`, `category`, `price`, `type`, `no-location`, `online-elsewhere`), `already_delivered`, `duplicates`, `from_organizer_pages` (events found through Luma calendars or Meetup group pages), `calls`, `refused`, `stop` (same values as in the webhook) and `notes`. The notes carry what you would otherwise find out later: a day above Eventbrite's wall, a group page that no longer exists, the 180 second pause after a refusal, the categories a source has no feed for.

A long run writes a `Progress` line every minute with the events kept so far and the requests per source.

### How much does it cost to scrape events?

You pay per event delivered, once per event in a run, plus a small start fee. Events outside the radius, filtered out, duplicated, already delivered in watch mode, or cut by your limit are free.

| Event | Free, Bronze, Silver | Gold and above |
|---|---|---|
| Event | $0.90 per 1,000 | $0.50 per 1,000 |
| Detailed event (Eventbrite and Luma, when the detail was fetched) | $1.80 per 1,000 | $1.00 per 1,000 |
| Run start, per GB of memory (512 MB by default, minimum one event) | $0.002 | $0.002 |

Meetup is always billed as an event, with or without **Include details**, because its lists are already complete.

Facebook, only when you add it to **Sources**:

| Event | Free, Bronze, Silver | Gold and above |
|---|---|---|
| Facebook event | $1.50 per 1,000 | $1.40 per 1,000 |
| Detailed Facebook event (Include details, or an event URL) | $9.50 per 1,000 | $9.50 per 1,000 |

On the free Apify plan, Facebook stops after a daily limit (`free-limit` in the status); the other sources are not limited.

Examples at the Free price:

| What you run | Events | Cost |
|---|---|---|
| A small test, one city, Max events 50 | 50 | about $0.05 |
| 1,000 events of any source | 1,000 | $0.902 ($0.502 on Gold) |
| Eventbrite, New York, 30 days | 16,556 | about $14.90 ($8.28 on Gold) |
| The same with the full description and the organizer page | 16,556 | about $29.80 ($16.56 on Gold) |
| Meetup, New York, 45 days | 11,461 | about $10.31 |
| Luma, New York, 25 km | about 2,000 | about $1.80 |
| The three sources, New York, 30 days | 26,687 | about $24.02 ($13.35 on Gold) |

For reference, a bundle actor on the Store that reads the same three sources charges $0.025 per run plus $0.99 per 1,000 events plus $0.001 per additional data item, which is $1.015 for 1,000 events before the additional data. This actor charges $0.902 for the same 1,000, including the start fee.

Set **Max events** or a maximum charge per run to stay within a budget: the run stops cleanly when it is reached and keeps what it already returned.

### Scrape events with Python, JavaScript or cURL

These examples use the actor `alexmorain/eventbrite-luma-meetup-scraper`. Replace the token with your own and keep it in an environment variable.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("alexmorain/eventbrite-luma-meetup-scraper").call(run_input={
    "locations": ["Austin, TX"],
    "radiusKm": 25,
    "startDate": "today",
    "endDate": "14 days",
    "categories": ["tech"],
    "maxItems": 0,
})

for event in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(event["source"], event["startLocal"][:16], event["title"], event["distanceKm"], event["organizerWebsite"])

coverage = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("COVERAGE")["value"]
for search in coverage:
    print(search["source"], search["target"], search["fetched"], "read,", search["delivered"], "delivered")
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('alexmorain/eventbrite-luma-meetup-scraper').call({
    startUrls: ['https://www.eventbrite.com/o/art-hearts-fashion-3598289939'],
    includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const e of items) console.log(e.title, e.startLocal, e.organizerInstagram, e.organizerVerified);
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/alexmorain~eventbrite-luma-meetup-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"locations": ["San Francisco"], "sources": ["meetup"], "maxItems": 50}'
```

A synchronous call times out after five minutes: use it for short runs. For a city over several weeks, start the run with `POST /v2/acts/alexmorain~eventbrite-luma-meetup-scraper/runs` and read the dataset when it ends. To get a CSV, add `&format=csv` to the dataset items URL.

### Tips for scraping events

- **Speed.** A small city over a few weeks takes under a minute. New York over 30 days on the three sources takes about 5.5 minutes. Eventbrite with **Include details** is the slowest option: one description request per event and one 235 KB organizer page per organizer. A 2 day run on New York with details read 1,627 events in 8 minutes.
- **Cap a first test.** Leave **Max events** at 50 the first time: the run stops as soon as it has them.
- **Turn off organizer pages for speed.** On Luma and Meetup, untick **Read organizer pages** for a quick, shallower run: you lose about a third of the events on Luma and about a third of the physical events on Meetup.
- **Parallel requests.** **Parallel requests** empty means each source's default: 4 on Luma (it refuses bursts), 8 on Meetup and Eventbrite.
- **One budget for three sources.** **Max events** is shared by the sources of a run. To cap each location or URL instead, use **Max events per search**.
- **Proxy.** Runs start from the actor's own IP and change to a fresh datacenter proxy session when a source answers 403 or 429. Eventbrite also changes session every 1,000 requests, before it bans the IP. With the proxy turned off, a 429 from Eventbrite makes the run wait 3 minutes, which makes a big run slow.

### Limits of this events scraper, written plainly

- **Eventbrite never serves everything it announces.** About 7% is missing even after seven passes, and the status shows `fetched` against `announced`. A day so dense that a category and a price slice is still above 1,000 results is named in the notes, with the slice that was cut.
- **No online events in a search by place on Eventbrite.** They have no position. Use an organizer URL to get an organizer's online events.
- **Meetup reads what the groups show.** A group that the area never mentioned and that is absent from Meetup's recommended feed is not found: this version does not search groups on their own. Events of private groups are not public.
- **Luma returns what its public calendars and discovery feed show.** Private calendars are skipped. Some events hide their address until you RSVP: they come back placed at the centre of their city, with `locationApproximate: true`.
- **No emails, no phone numbers, no attendee lists.** None of the four platforms serves the organizer's email. Eventbrite organizer links are the website, Facebook and Twitter from the list, and Instagram from the organizer page with details. The Instagram field is left empty when Eventbrite only gives an internal numeric id.
- **Prices are the ticket range shown.** `priceMin` and `priceMax` are the lowest and highest ticket price in currency units. An event with a free ticket and a paid one has `isFree: false` and `priceMin: 0`. A Meetup event with an optional contribution is `isFree: true` with the amount in `priceMax`. Fees added at checkout are not included.
- **Meetup has no "free" field.** An event without a fee setting is returned as free.
- **Facebook gives no price, no category and no end time.** Those fields are `null` on Facebook rows. Without **Include details** the position is the centre of the city page, and the organizer is not known.
- **Facebook reads city pages only.** The events of a Facebook page or a group are not read in this version, and a place without a Facebook city page within 40 km is reported in the notes with no Facebook events.
- **Events already over are skipped.** The actor does not return past events.
- **Coordinates of a place name.** A place name becomes a centre with an offline list of places of 1,000 inhabitants or more. The most populated place with that name wins: add a state or a country to pick another one, or give latitude and longitude.

### Events scraper FAQ

#### How to scrape Eventbrite events by city?

Type the city in **Locations**, choose **Eventbrite** in **Sources** and press Start. New York over 30 days returned 13,500 to 16,500 events, against about 975 for one plain search. No Eventbrite account or API key.

#### Is there an Eventbrite API to search events by location?

Eventbrite's API no longer offers a public search of events by location. This actor reads the JSON service that eventbrite.com itself calls to display search results, so it works without a key. It is not Eventbrite's official API, and the fields follow what the website uses.

#### Why does my Eventbrite scraper stop at 1,000 events?

Because Eventbrite stops at 1,000 results for any one search, whatever it announces ("10,000"). The page after the 50th is empty. The way around it is to make smaller searches: one per day, then per category and per price. That is what the actor does.

#### How to export Eventbrite events to CSV or Excel?

Run the actor, open the dataset of the run and choose CSV, Excel, JSON or XML in the export menu. By the API, add `format=csv` to the dataset items URL. The columns are flat, except `categories`, `tags` and `hosts`, which are lists.

#### Is there a Meetup events scraper without an API key?

Yes, this one. It reads the GraphQL service of meetup.com with no account, no API key and no cookie. Meetup's official API needs a Pro subscription; this actor does not use it.

#### How many events can I scrape from Meetup?

One Meetup search returns about 600. The actor reads one day at a time and then the page of every group it saw, which gave 11,461 events within 25 km of New York over 45 days.

#### Luma events API: can I get all the events of a city?

Luma's API is meant for the owners of a calendar, not for browsing a city. The actor reads Luma's discovery feed around your coordinates, then the public calendar of each organizer found, and returns about 2,000 events within 25 km of New York, against about 70 on the city page. Add **Include details** for the description and the ticket prices by type.

#### Can I scrape Eventbrite, Meetup and Luma in one run?

Yes. Leave **Sources** empty for these three, or tick them with Facebook for four. They share one event budget (**Max events**), the same columns and the same filters. The `source` field tells them apart, and an event is never returned twice by the same source. An event published on two platforms is returned once for each.

#### How do I get the email of the organizer?

You cannot with this actor, and not with any of the four platforms: none of them gives the organizer's email. You get the organizer's website, Facebook, Twitter, LinkedIn, Instagram and other profiles when the platform shows them (see the field table for which). From the website you can use another tool to find a public contact address.

#### Can I get only free events, or only online events?

Yes. **Price** keeps free or paid events, **Attendance** keeps in person or online events. Online events only come from Luma and Meetup, and only from organizers within the radius.

#### Can I scrape the events of one organizer or one group?

Yes, paste its URL in **Start URLs** (Eventbrite `/o/...`, a Meetup group, a Luma calendar). You get its upcoming events.

#### How do I get alerts when a new event appears?

Turn on **New events only**, give the run a watch name, schedule it daily and add a webhook URL. Each run returns, and charges, only the events it has not delivered before.

#### Is it legal to scrape Eventbrite, Meetup and Luma?

This is not legal advice. The actor reads what the four websites show to any visitor, without a login and without private account data. Whether collecting it is allowed depends on what you do with it, where you are, and each platform's terms of use, which limit automated access and the reuse of their content. Our actors do not extract private user data such as email addresses or gender. Your results can still contain personal data, such as the first name of a Meetup host, the name of a Luma host or a Facebook host page. Personal data is protected by the GDPR in the European Union and by other regulations around the world. Do not scrape personal data unless you have a legitimate reason, and if you are unsure whether yours is legitimate, consult a lawyer. This actor is not affiliated with or endorsed by Eventbrite, Meetup, Luma or Meta.

### Support

Something wrong or missing? Open an issue in the Issues tab with the run id and the input. To call the actor from your own code, see the API tab.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Events Scraper page](https://alexis.morain.fr/en/scrapers/eventbrite-luma-meetup-scraper/) of my site. The [Lead generation family page](https://alexis.morain.fr/en/scrapers/families/lead-generation/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

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

Cities to search, one per line: <code>Paris</code>, <code>Austin, TX</code>, <code>London, UK</code>, <code>Lyon, France</code> or <code>48.85, 2.35</code>. The centre is the most populated place of that name; add a state or country to pick another. Events are kept when they are within <b>Radius</b> of the centre. Leave empty if you only give start URLs.

## `latitude` (type: `number`):

Optional centre as coordinates, an alternative to a city name. Set it together with <b>Longitude</b>.

## `longitude` (type: `number`):

Optional centre as coordinates. Set it together with <b>Latitude</b>.

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

Keep events whose venue is within this straight-line distance of the centre. Each row carries <code>distanceKm</code>. Events outside the radius are read but not delivered and not charged.

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

Where to look. Empty means Luma, Eventbrite and Meetup. Facebook is read only when you tick it: public events of the Facebook city page of each location (a place name, not coordinates), charged as <code>facebook-event</code>. Facebook lists no price and no category, so it is skipped when Price or Categories is set.

## `startUrls` (type: `array`):

Optional pages to read instead of, or on top of, the locations. Luma: an event, an organizer calendar, a city page such as <code>https://luma.com/nyc</code> or a category page (short links <code>lu.ma/abc123</code> work). Eventbrite: an event page <code>https://www.eventbrite.com/e/...-tickets-\<id></code> (any Eventbrite domain) or an organizer page <code>https://www.eventbrite.com/o/\<name>-\<id></code> (its upcoming events, online ones included, as listed on the page). Meetup: a group page <code>https://www.meetup.com/\<group>/</code> (events up to 180 days ahead unless you set an end date) or an event page <code>https://www.meetup.com/\<group>/events/\<id>/</code>. Facebook: an event page <code>https://www.facebook.com/events/\<id>/</code> (always read with its details) or a city page <code>https://www.facebook.com/events/explore/\<city>/\<id>/</code>. A city page is read around its centre with the radius above. Pages are never filtered by distance, only by the common filters below.

## `keywords` (type: `array`):

Keep events whose title, organizer, venue, categories or tags contain at least one of these words (case-insensitive). Eventbrite and Meetup search the words themselves (Eventbrite: the exact word in the full text, one search per word and day; Meetup: one search per word and day), so a keyword finds far more than the plain feed. On Luma the description is searched only when <b>Include details</b> is on.

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

Earliest start: <code>2026-12-01</code>, <code>2026-12-01T18:00:00Z</code>, <code>today</code> or a relative time ahead such as <code>7 days</code>. A date without a time is a local day: events whose start day on the spot is that day or later. A date with a time is an exact instant (UTC). Meetup reads from now at the earliest.

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

Latest start, same formats. A date without a time includes the whole day (local day of the event for Eventbrite and Meetup). Without it, Meetup's feed is read 70 days ahead (it is empty beyond about 10 weeks) and so is Eventbrite; a later date is accepted by Eventbrite, and covered by organizer group pages only on Meetup.

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

Keep events of these unified categories. Luma reads its category feeds (tech, ai, crypto, climate, health-wellness, fitness-sports, arts-culture, food-drink, family); Meetup its 20 categories (all except food-drink); Eventbrite its 20 categories (a fine category such as ai, crypto, startups or climate reads the wider parent category, Science & Tech or Business). A category with no feed on a source returns nothing there, with a note. Organizer calendars and group pages are not read when a category is set.

## `eventType` (type: `string`):

In person keeps events with a venue (hybrid included); Online keeps online and hybrid events. Empty means any. Eventbrite has no way to tie an online event to a place: with a location, it returns no online event (an organizer URL in startUrls returns that organizer's online events).

## `priceFilter` (type: `string`):

Free keeps events that cost nothing, Paid keeps events with a ticket price. Empty means any.

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

Stop after this many events delivered, all searches together. <code>0</code> removes the limit (a big city holds thousands of events and you pay per event). Empty means 100.

## `maxItemsPerSearch` (type: `integer`):

Stop each location or start URL after this many events. Empty or <code>0</code> means no limit.

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

Fetch more for each delivered event. Luma: the event page (full description as text, categories, price range across ticket types, capacity). Eventbrite: the full description and the organizer page (Instagram, verified badge, bio), one organizer page per organizer for the whole run. Meetup: nothing to fetch, its lists already carry all of this. Charged as <code>event-with-details</code> for Luma and Eventbrite events that obtained their detail; any other event is a plain <code>event</code>. Facebook: the event page (exact position and address, description, organizer and host pages), charged as <code>facebook-event-with-details</code>.

## `includeOrganizerCalendars` (type: `boolean`):

Besides the area feed, read the pages of the organizers found there. Luma: the public calendars of the organizers (about 50% more events in a big city). Meetup: every group seen in the feed, which adds the events Meetup's recommended feed leaves out (about 1.5 times the physical events in New York). Longer run; untick it for a faster, shallower one. Not used with Meetup categories or keywords, and not used by Eventbrite (it has no organizer feed). On by default.

## `newOnly` (type: `boolean`):

Deliver only events not delivered by an earlier run of the same watch. The run still reads everything, so events that appear late are never missed; already delivered events are skipped and not charged.

## `registryKey` (type: `string`):

Optional name of this watch. Two schedules with different names keep separate memories. Without a name, the memory is tied to the locations, sources, URLs and filters (not the dates), so changing any of them starts a new watch.

## `webhookUrl` (type: `string`):

Optional. At the end of the run, a JSON summary (status, events delivered, per-search coverage) is POSTed here. Never written to the logs.

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

Requests in flight at the same time on each source. Leave empty for the per-source default: 4 on Luma, which refuses bursts, 8 on Meetup and Eventbrite. The run backs off and changes IP on refusals.

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

Runs start from the Actor's own IP. On a refusal (HTTP 403 / 429) the run switches to a fresh Apify datacenter proxy session and retries; Eventbrite also changes session every 1,000 calls before it can ban the IP. Turn it off to wait and retry on the same IP instead (Eventbrite: a 3-minute pause after a 429, which makes big runs slow). Empty means the Apify datacenter proxy.

## Actor input object example

```json
{
  "locations": [
    "San Francisco"
  ],
  "radiusKm": 25,
  "sources": [
    "eventbrite"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per event: date, venue, price, organizer

## `organizers` (type: `string`):

Organizer contacts and social profiles per event

## `dataset` (type: `string`):

Every row with all fields

# 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": [
        "San Francisco"
    ],
    "radiusKm": 25,
    "sources": [
        "eventbrite"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/eventbrite-luma-meetup-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": ["San Francisco"],
    "radiusKm": 25,
    "sources": ["eventbrite"],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/eventbrite-luma-meetup-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": [
    "San Francisco"
  ],
  "radiusKm": 25,
  "sources": [
    "eventbrite"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call alexmorain/eventbrite-luma-meetup-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alexmorain/eventbrite-luma-meetup-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/L2vginKtVmdWcuvNj/builds/ggfcaTvAzNJ7KmeIH/openapi.json
