# Meetup Events Scraper — Whole City, Groups, Past RSVPs (`chorelet/meetup-events-scraper`) Actor

Every public Meetup event in a city, not just the first page of a keyword search: date, venue and coordinates, RSVP and waitlist counts, fee, host and group. Plus group profiles with member counts and past events with the attendance each one drew.

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

## Pricing

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

## Meetup Events Scraper — Whole City, Groups, Past RSVPs

Every public event on **Meetup.com** for a city — not the first page of a keyword search. Leave the keywords empty and the Actor sweeps the city's whole feed: hundreds of events with date, venue and coordinates, RSVP and waitlist counts, fee, host and the group behind them, as JSON, CSV or Excel, or through the API.

It reads Meetup's own public GraphQL endpoint, the one the website calls in your browser. No account, no API key, no cookies. Two more modes come with it: **group profiles** for a city (members, founded date, organiser, rating) and the **past events of a group** with the attendance each one actually drew — the honest way to tell a living community from a dormant one.

Attendance is reported as counts only. Meetup's API will hand out the names of everyone who RSVP'd; this Actor never collects them.

### Why this Actor

- **The whole city, not the first 50 search hits.** Meetup's keyword search caps out quickly; this Actor sweeps a city with no keyword at all and can widen the sweep across all 20 topic categories — 924 Berlin events in one run during testing.
- **Past events with attendance.** A group's entire history with the number of people who went, back to the first meetup. That is how you tell a living community from a dormant one — no other Meetup Actor offers it.
- **Three modes, one schema.** Events, group profiles and group history share the same fields, so a city scan and a community audit land in the same spreadsheet.
- **Counts only, never people.** The API happily returns named attendees; this Actor refuses to emit them and checks every row before it is saved.

### Sample output

One item of the dataset (long values shortened):

```json
{
  "title": "English stand-up: Sunday Comedy Party",
  "startsAt": "2026-09-27T19:30:00+02:00",
  "groupName": "East-West Comedy Berlin",
  "venueCity": "Berlin",
  "goingCount": 17,
  "isOnline": false,
  "isFree": true,
  "eventUrl": "https://www.meetup.com/berlinexpatevents/events/316460607/"
}
```

### What you get

- **The whole city, not 30 hits.** Keyword search on Meetup runs out at 30–70 events per city and stops; the keyword-free sweep returns hundreds — 518 upcoming Berlin events in one pass, 924 with the topic-category widening on
- RSVP count, waitlist count, RSVP cap and spots left on every event — demand, not just a listing
- Venue name, street address, city, country and coordinates; online events are flagged instead of being given a fake location
- The group behind every event: name, urlname, member count, topic category, link
- `groups` mode: the city's groups with member count, founded date, organiser, average rating and rating count — over 2,000 of them for Berlin, where keyword search stops at 200
- `group-history` mode: a group's past events, newest first, each with the attendance it drew — no competitor publishes this
- Filters for in-person vs online, minimum attendance and a date window, so a daily run returns only what is new
- Monitored daily

### Input

- **What to scrape** — `events` (default), `groups`, or `group-history`
- **Cities** — plain names, resolved by Meetup itself: `Berlin, Germany`, `New York`, `Austin, TX, USA`, `Tbilisi, Georgia`. No geocoding key, no coordinates
- **Keywords** — one search per keyword. **Leave empty in `events` and `groups` mode to sweep the whole city**
- **Groups** — for `group-history`: `https://www.meetup.com/python-users-berlin-pub/` or the bare urlname
- **Search radius**, **Starts after** / **Starts before** (`2026-10-01`, `7 days`, `1 year ago`), **Event type**, **Minimum attendees**
- **Widen the sweep across topic categories** — repeats the city sweep once per Meetup category for full coverage
- **Max events per city or group**, **Max groups per city**, **Fetch per-event details**

### Limits and notes

- Meetup's city feed reaches about one month ahead and tops out near 520 upcoming events per city; a longer date window does not add events, and `Widen the sweep across topic categories` is the way to get the rest — it took Berlin from 518 to 924 events in 82 seconds.
- Keyword search returns roughly 30–70 events per city and keyword before Meetup runs out of hits, and group search stops at 200 groups per term. These are the API's limits, not the Actor's — which is exactly why the keyword-free sweep exists.
- Some organisers publish an in-person event without a venue (about 2% of rows): `venueName` and the coordinates are then null, and the event page shows the location only to members who RSVP.
- `radius` is in miles and Meetup snaps it to its own bands — 10 and 20 usually return nearly the same set for a large city.
- `goingCount` is the people who said yes; `rsvpCount` adds the ones who answered no, so it is the same or higher. `maxTickets` is the cap the organiser set — a handful of events carry a stale cap below their own attendance, so treat `spotsRemaining: 0` as "no seats advertised", not as proof the door is shut.
- On group rows `latitude` and `longitude` are the coarse point Meetup publishes for the group, rounded to two decimals: every group in a smaller city shares the city-centre coordinate. Event rows carry the real venue point.
- Fees are only reported when the organiser collects payment through Meetup; an event with no `feeSettings` is published as free, which is also what the website shows.
- `Fetch per-event details` costs one extra request per event and is charged separately. The list already carries the description, topics, hosts, venue and counts, so turn it on only for the organiser-side fields: directions, guest policy, waitlist mode, recurring-series id and the full group profile.
- Attendee names, waitlist names and group member rosters are available from the endpoint and are deliberately not collected — every person figure in the output is a count.

### Input example

```json
{
  "mode": "events",
  "cities": [
    "Berlin, Germany"
  ],
  "groupUrlnames": [
    "python-users-berlin-pub"
  ],
  "radius": 10,
  "startsBefore": "7 days",
  "eventType": "any",
  "minAttendees": 0,
  "sweepCategories": false,
  "maxEvents": 60,
  "maxGroups": 50,
  "fetchEventDetails": false
}
```

### How much does it cost?

Pay per event — no subscription, no minimum, no charge for platform usage.

| Volume | Price |
|---|---|
| 1,000 events | $1.00 (+ $0.80 with `group`) |
| 10,000 events | $10.00 (+ $8.00 with `group`) |
| 100,000 events | $100.00 (+ $80.00 with `group`) |

The Apify **free plan includes $5 of usage every month** — about 5,000 events with this Actor, no card needed. Nothing else is charged: platform usage is included in the price, and Apify Bronze, Silver and Gold subscribers get 10%, 20% and 30% off these prices.

### Use it from code, n8n, Make, Zapier or an AI agent

Run the Actor and download the dataset in one call (JSON by default; add `&format=csv` or `xlsx`):

```bash
curl -X POST "https://api.apify.com/v2/acts/chorelet~meetup-events-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode": "events", "cities": ["Berlin, Germany"], "groupUrlnames": ["python-users-berlin-pub"], "radius": 10, "startsBefore": "7 days", "eventType": "any", "minAttendees": 0, "sweepCategories": false, "maxEvents": 60, "maxGroups": 50, "fetchEventDetails": false}'
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("chorelet/meetup-events-scraper").call(run_input={"mode": "events", "cities": ["Berlin, Germany"], "groupUrlnames": ["python-users-berlin-pub"], "radius": 10, "startsBefore": "7 days", "eventType": "any", "minAttendees": 0, "sweepCategories": false, "maxEvents": 60, "maxGroups": 50, "fetchEventDetails": false})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

- **n8n, Make, Zapier** — use the Apify node/module: run the Actor, then "get dataset items".
- **Google Sheets, Slack, webhooks** — add an integration on the run's *Integrations* tab.
- **AI agents** — the Actor is available as a tool through the Apify MCP server; the dataset schema describes every field for the model.
- **Schedules** — run it hourly, daily or weekly from the *Schedules* tab.

### FAQ

**How do I get every event in a city?**

Leave *Keywords* empty: with no keyword the Actor uses Meetup's recommendation feed, which is not capped the way search is. Turn on *Sweep topic categories* to widen it further — that is what took a Berlin run from 518 to 924 events.

**Can I see past events and how many people came?**

Yes — that is the `group-history` mode. Give it group URL names and it pages through their history with the attendance count of each past event.

**Do I get attendee names?**

No, and that is deliberate. Meetup's API exposes named members; this Actor emits counts only and validates every row before saving it.

**How do I write the city?**

As a plain string — `Berlin, Germany`, `New York, NY`, `Bangalore`. It is resolved through Meetup's own location search, so no coordinates and no geocoding key are needed.

**Does it need a Meetup account?**

No. Everything comes from the public endpoint meetup.com itself calls, with no login, no cookies and no API key.

### Support

Questions, missing fields or a source that changed? Open an issue on the *Issues* tab or write to support@chorelet.app — problems are usually fixed within a day, and the Actor is checked every morning by an automated test run. If the Actor saved you time, a short review on its Store page helps other people find it.

# Actor input Schema

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

`events` — public events in a city (leave keywords empty to sweep the whole city). `groups` — group profiles with member counts, founded date, organiser and rating. `group-history` — past events of specific groups with the attendance each one drew.

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

Plain place names, `City, Country` or `City, State, Country`: `Berlin, Germany`, `New York`, `Austin, TX, USA`, `Tbilisi, Georgia`. Meetup resolves each one itself — no geocoding key, no coordinates. Used by the `events` and `groups` modes.

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

Each keyword is a separate search, e.g. `python`, `startup`, `board games`. **Leave this empty in `events` and `groups` mode to sweep the whole city** — keyword search returns only a few dozen events (or 200 groups) per city, the sweep returns hundreds. In `group-history` mode keywords filter the past events by title, description or topic.

## `groupUrlnames` (type: `array`):

Group URLs or bare urlnames for `group-history` mode: `https://www.meetup.com/python-users-berlin-pub/` or `python-users-berlin-pub`.

## `radius` (type: `integer`):

Miles around the city centre. Meetup snaps this to its own bands, so 10 and 20 usually return almost the same set.

## `startsAfter` (type: `string`):

Absolute `2026-10-01` or relative `2 days`. Empty = from now on. For `group-history` use a past offset: `1 year ago` or `-6 months`.

## `startsBefore` (type: `string`):

Absolute `2026-12-31` or relative `30 days`. Meetup's own city feed reaches about a month ahead, so a longer window will not add events.

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

Keep only in-person or only online events.

## `minAttendees` (type: `integer`):

Drop events with fewer RSVPs than this. Use it to skip the long tail of events nobody signed up for.

## `sweepCategories` (type: `boolean`):

After the plain city sweep, run it again once per Meetup topic category (Technology, Music, Sports & Fitness, …). Finds a few dozen extra events per category at the cost of one pass each — slow, so leave it off unless you need full coverage.

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

Limit the widened sweep to specific categories by name or url key: `technology`, `career-business`, `social-activities`, `music`, `art-culture`, `games`, `health-wellbeing`, `sports-fitness`. Empty = all 20.

## `maxEvents` (type: `integer`):

Meetup's city feed tops out at roughly 500 upcoming events per city, whatever you put here.

## `maxGroups` (type: `integer`):

The keyword-free city sweep reaches past 2,000 groups for a large city. A keyword search is capped by Meetup at 200 groups per term.

## `fetchEventDetails` (type: `boolean`):

One extra request per event: how to find the venue, guest policy, waitlist mode, recurring-series id, map link, and the full group profile (founded date, organiser, rating, join mode). Charged separately.

## Actor input object example

```json
{
  "mode": "events",
  "cities": [
    "Berlin, Germany"
  ],
  "keywords": [],
  "groupUrlnames": [
    "python-users-berlin-pub"
  ],
  "radius": 10,
  "startsBefore": "7 days",
  "eventType": "any",
  "minAttendees": 0,
  "sweepCategories": false,
  "categories": [],
  "maxEvents": 60,
  "maxGroups": 50,
  "fetchEventDetails": false
}
```

# Actor output Schema

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

All rows — items of the default dataset. Use ?format=csv or xlsx on this URL for spreadsheets.

## `summary` (type: `string`):

Mode, resolved places, rows per target, details fetched and errors.

# 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": "events",
    "cities": [
        "Berlin, Germany"
    ],
    "keywords": [],
    "groupUrlnames": [
        "python-users-berlin-pub"
    ],
    "radius": 10,
    "startsAfter": "",
    "startsBefore": "7 days",
    "eventType": "any",
    "minAttendees": 0,
    "sweepCategories": false,
    "categories": [],
    "maxEvents": 60,
    "maxGroups": 50,
    "fetchEventDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("chorelet/meetup-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 = {
    "mode": "events",
    "cities": ["Berlin, Germany"],
    "keywords": [],
    "groupUrlnames": ["python-users-berlin-pub"],
    "radius": 10,
    "startsAfter": "",
    "startsBefore": "7 days",
    "eventType": "any",
    "minAttendees": 0,
    "sweepCategories": False,
    "categories": [],
    "maxEvents": 60,
    "maxGroups": 50,
    "fetchEventDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("chorelet/meetup-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 '{
  "mode": "events",
  "cities": [
    "Berlin, Germany"
  ],
  "keywords": [],
  "groupUrlnames": [
    "python-users-berlin-pub"
  ],
  "radius": 10,
  "startsAfter": "",
  "startsBefore": "7 days",
  "eventType": "any",
  "minAttendees": 0,
  "sweepCategories": false,
  "categories": [],
  "maxEvents": 60,
  "maxGroups": 50,
  "fetchEventDetails": false
}' |
apify call chorelet/meetup-events-scraper --silent --output-dataset

```

## MCP server setup

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