# Meetup Scraper - Events, Groups & Members Data Extractor (`haketa/meetup-scraper`) Actor

Meetup scraper & API: search events and groups by topic and location and export event name, date, venue, description, group, attendee count, organizer and RSVP URL. Event discovery, community research and lead generation — fast, no login.

- **URL**: https://apify.com/haketa/meetup-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Social media, Lead generation, Marketing
- **Features:** Limited permissions
- **Stats:** 63 total users, 15 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 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.
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 Scraper – Extract Events, Groups, Members & Venues from Meetup.com

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-00B4D8?style=for-the-badge\&logo=apify\&logoColor=white)](https://apify.com/haketa/meetup-scraper)
[![Meetup Events](https://img.shields.io/badge/Target-Meetup.com-ED1C40?style=for-the-badge\&logo=meetup\&logoColor=white)](https://www.meetup.com)
[![Pagination](https://img.shields.io/badge/Pagination-1%2C000%2B_Records-2EA44F?style=for-the-badge)]()
[![No Login](https://img.shields.io/badge/Auth-No_Login_or_Key-8A2BE2?style=for-the-badge)]()
[![Export Formats](https://img.shields.io/badge/Export-JSON_%7C_CSV_%7C_Excel_%7C_API-FF9900?style=for-the-badge)]()

**Meetup Scraper** is a fast, reliable tool to **scrape Meetup.com** at scale – no Meetup API key, no login, no coding required. Search events by keyword and city, or paste any event or group URL, and export clean, structured **Meetup data** to JSON, CSV, Excel, HTML or XML in seconds.

Whether you need **event data** for market research, **group and community data** for lead generation, or **attendee and organizer insights** for sales prospecting, this **Meetup data extractor** turns the public Meetup.com website into a ready-to-use dataset. Export to **JSON, CSV, Excel, or API**.

> ⚡ **TL;DR** – Type a keyword + a city (or paste URLs), press **Start**, and download a spreadsheet of Meetup events, groups, organizers, RSVP counts, venues and members.

> 🧑‍💼 **Built for** growth marketers and SDRs building targeted outreach lists, event organizers and sponsors scouting active communities, developer-relations and community teams, researchers and data scientists studying local activity, and founders doing competitive and market research.

***

### ⚡ At a glance

| Feature | Details |
|---|---|
| **Target Website** | [Meetup.com](https://www.meetup.com) — global local events, groups, organizers & communities |
| **Extraction Modes** | (1) Keyword + City Search, (2) Direct Event URLs, (3) Group URLs (with upcoming/past events & members) |
| **Core Data Extracted** | Event title, dates, RSVP (`goingCount`) & waitlist, ticket fee, venue + GPS, host profiles, group stats, member roles |
| **Pagination & Scale** | Automatic cursor pagination (50 items/page) + multi-topic expansion for **1,000+ unique events** |
| **Authentication** | None required — 100% public data, no Meetup OAuth or API key needed |
| **Export Formats** | JSON, CSV, Excel (XLSX), HTML table, XML, RSS, and direct REST API / MCP / Webhooks |

***

### 🔎 Why scrape Meetup.com?

[Meetup.com](https://www.meetup.com) is one of the largest platforms for local communities, professional networking, tech meetups, hobby groups and live events worldwide. Every day it publishes thousands of events with exact RSVP counts, venues, organizers and group sizes – a uniquely rich, real-time picture of who is gathering, around what topic, and where.

That data is incredibly valuable, but collecting it by hand is painful. Meetup's official API is rate-limited, requires OAuth authentication, and is effectively unusable for non-developers. Copy-pasting events one page at a time is slow, error-prone, and impossible to keep fresh. This **Meetup scraper** removes all of that friction: it talks directly to Meetup's own structured data layer and hands you a clean, de-duplicated dataset in one run – no key, no login, no browser automation to babysit.

**Common reasons people scrape Meetup.com:**

- 🎯 Build targeted **lead lists** of groups, organizers and engaged community members by topic and city.
- 📣 Find active, well-attended events to **sponsor, speak at, or promote**.
- 📊 Track which **topics, technologies and communities** are growing in any market.
- 🗓️ Power an **event website, newsletter or app** with a continuously refreshed feed of local and online events.
- 🔍 Run **competitive and market research** on rival communities and event formats.
- 🧑‍🔬 Collect structured datasets for **academic and data-science** research on networking and local activity.
- 🤝 Discover groups to **partner with, join, or recruit from**.

***

### ✨ What this Meetup scraper does

- ✅ **No API key and no login required** – works straight out of the box on public Meetup.com data.
- ✅ **Three input modes** – (1) keyword + city **search**, (2) direct **event URLs**, (3) **group URLs** (optionally pulling the group's full event history and a sample of members).
- ✅ **Automatic pagination** – walks Meetup's GraphQL **cursor pagination** (50 records per page) across every page and returns **hundreds to thousands** of de-duplicated records.
- ✅ **Rich, structured event fields** – exact `goingCount` (RSVP), `waitlistCount`, capacity, price, `topics`, full `venue` (address + lat/lon), `hosts`, and the host group (see the full field reference below).
- ✅ **Group & member data** – group size, category, location, organizer and founding date; plus a public sample of members with role flags (`isOrganizer`, `isLeader`, `isProOrganizer`).
- ✅ **Filters & targeting** – event type (online / in-person), date range, sort order, and a per-run `maxItems` cap.
- ✅ **Geocoding built in** – just type "London" or "New York"; the scraper resolves the city to coordinates automatically (no coordinates or Meetup location ID needed).
- ✅ **Reliable at scale** – datacenter proxies by default with **automatic escalation to residential** if Meetup throttles, **fresh IP on every retry**, and empty-page retries so results stay complete.
- ✅ **Export anywhere** – JSON, CSV, Excel, HTML, XML, or pull straight from the **Apify API**.

***

### 🎯 Use cases

- **Lead generation & sales prospecting** – build targeted lists of Meetup groups and their organizers by topic and city, then reach out with relevant offers.
- **Event marketing & sponsorship discovery** – identify active, well-attended events in your industry to sponsor, speak at, or promote; filter by `goingCount` to find the events that actually matter.
- **Market & competitive research** – monitor competitor events, measure community size, and spot emerging topics before anyone else.
- **Event aggregation & directories** – feed your own event site, app or newsletter with fresh local and online events, complete with descriptions, dates, venues and images.
- **Community management & DevRel** – discover relevant groups to partner with, find guest speakers, and benchmark your community against others.
- **Recruiting & talent sourcing** – surface engaged, skill-specific communities and their organizers.
- **Academic & data-science research** – collect structured datasets on social gatherings, networking behavior and online-vs-in-person event trends.
- **Travel & logistics planning** – pair event schedules and venues with hotel and rental data for conference and event logistics.

***

### 📥 Input

Configure the run in the Apify Console UI or via JSON/API. You can use **search mode**, **URL mode**, or both at once.

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | array of strings | `["technology"]` | Keywords to search events for (e.g. `javascript`, `yoga`, `startup networking`). Each keyword is searched separately in the chosen city. Leave empty to get a ready-made mix of popular events. |
| `city` | string (select) | `New York` | City to search events in, chosen from a built-in list of 24 major cities (New York, London, Berlin, San Francisco, Tokyo, Bangalore…). Keyword search always runs against a city. |
| `customCity` | string | – | Any city **not** in the dropdown (e.g. `Lisbon`, `Denver, USA`, `Cape Town`). When filled it **overrides** `city`. Auto-geocoded — no coordinates needed. |
| `eventType` | string | `any` | `any`, `online`, or `physical` (in-person). |
| `dateRange` | string | `any` | `any`, `today`, `tomorrow`, `this-week`, `this-weekend`, `next-week`, `this-month`. Applies to upcoming events. |
| `sortBy` | string | `relevance` | `relevance` or `date` (soonest first). |
| `startUrls` | array of URLs | – | Meetup **event** or **group** page URLs to scrape directly. Works with or without the keyword search. |
| `scrapeGroupEvents` | boolean | `true` | For group URLs, also scrape the group's upcoming & past events as separate event records. |
| `scrapeGroupMembers` | boolean | `false` | For group URLs, also scrape the publicly listed sample of members and organizers. |
| `includeFullEventDetails` | boolean | `false` | Reserved toggle. The GraphQL search already returns full event objects, so this is off by default. |
| `maxItems` | integer | `0` (no limit) | Maximum number of records (events + groups + members) across the whole run. Use it to control cost. |
| `maxConcurrency` | integer | `10` | Maximum parallel requests. |
| `maxRequestRetries` | integer | `3` | Retries per failed request. |
| `proxyConfiguration` | object | Apify Proxy (datacenter) | Proxy settings. Datacenter by default (low-cost); auto-escalates to residential if Meetup blocks. You can also force residential or your own proxies. |

#### Example 1 – Search events by keyword and city

Find up to 200 JavaScript events in London:

```json
{
  "searchQueries": ["javascript", "web development"],
  "city": "London",
  "eventType": "any",
  "dateRange": "this-month",
  "sortBy": "date",
  "maxItems": 200
}
```

> Pick `city` from the dropdown, or use `customCity` for any city not listed (e.g. `"customCity": "Lisbon"`). `customCity` always overrides `city`.

#### Example 2 – Scrape a specific group, its events and members

```json
{
  "startUrls": [
    { "url": "https://www.meetup.com/london-scala/" }
  ],
  "scrapeGroupEvents": true,
  "scrapeGroupMembers": true,
  "maxItems": 500
}
```

#### Example 3 – Scrape individual event pages

```json
{
  "startUrls": [
    { "url": "https://www.meetup.com/london-scala/events/314859429/" }
  ]
}
```

#### Example 4 – Online events in a city

```json
{
  "searchQueries": ["product management"],
  "city": "San Francisco",
  "eventType": "online",
  "maxItems": 100
}
```

> Keyword search always runs against a city (Meetup's event search is location-based). Online events still show up in any city's results. If you leave `searchQueries` **and** `startUrls` empty, the scraper auto-seeds a diverse sample of popular events for the chosen city so a run is never empty.

***

### 📤 Output

The scraper writes **one record per event, group or member** to the dataset. Each record carries a `type` field (`event`, `group` or `member`) so you can filter and split records easily. Every example below mirrors the **real fields returned by a live run**.

#### Event record

```json
{
  "type": "event",
  "id": "316963808",
  "title": "Web Content Accessibility Guidelines 3.0 Discussion",
  "url": "https://www.meetup.com/a11ynyc/events/316963808/",
  "eventType": "PHYSICAL",
  "isOnline": false,
  "status": "ACTIVE",
  "startDateTime": "2026-11-10T19:30:00-05:00",
  "endDateTime": "2026-11-10T21:00:00-05:00",
  "durationMs": "PT1H30M",
  "createdTime": "2026-10-13T14:50:13-04:00",
  "description": "Thomas Logan will give a short tour of the latest W3C Working Draft...",
  "howToFindUs": "Ring the bell for the 3rd floor.",
  "goingCount": 58,
  "waitlistCount": 0,
  "maxTickets": 85,
  "spotsLeft": 27,
  "guestsAllowed": false,
  "isFree": true,
  "feeAmount": null,
  "feeCurrency": null,
  "topics": ["Web Accessibility", "Front End Development", "JavaScript"],
  "photo": "https://secure.meetupstatic.com/photos/event/highres_534060066.jpeg",
  "hosts": [
    { "name": "Thomas Logan", "memberId": "405145336", "memberUrl": "https://www.meetup.com/members/405145336/" }
  ],
  "venue": {
    "name": "Equal Entry",
    "address": "25 Broadway",
    "city": "New York",
    "state": "NY",
    "postalCode": "10004",
    "country": "us",
    "lat": 40.705,
    "lon": -74.013
  },
  "groupId": "19876543",
  "groupName": "Accessibility NYC",
  "groupUrlname": "a11ynyc",
  "groupUrl": "https://www.meetup.com/a11ynyc",
  "groupMemberCount": 2187,
  "groupCity": "New York",
  "groupCountry": "us",
  "searchKeyword": "technology",
  "searchLocation": "New York",
  "scrapedAt": "2026-11-01T23:35:12.994Z"
}
```

#### Group record

```json
{
  "type": "group",
  "id": "1562942",
  "name": "London Scala User Group",
  "urlname": "london-scala",
  "url": "https://www.meetup.com/london-scala",
  "description": "Come and meet other software developers in the London area interested in the Scala programming language...",
  "memberCount": 3976,
  "city": "London",
  "state": "17",
  "country": "gb",
  "postalCode": "EC1V 7DP",
  "lat": 51.52,
  "lon": -0.1,
  "timezone": "Europe/London",
  "foundedDate": "2009-11-28T18:25:10Z",
  "isPrivate": false,
  "joinMode": "OPEN",
  "category": "Technology",
  "photo": "https://secure.meetupstatic.com/photos/event/highres_468051360.jpeg",
  "organizerName": "Zainab Ali",
  "organizerUrl": "https://www.meetup.com/members/190278895/",
  "scrapedAt": "2026-11-01T23:40:24.599Z"
}
```

#### Member record

```json
{
  "type": "member",
  "id": "5719145",
  "name": "Barry",
  "url": "https://www.meetup.com/members/5719145/",
  "bio": null,
  "city": null,
  "state": null,
  "country": null,
  "isOrganizer": true,
  "isLeader": true,
  "isProOrganizer": true,
  "status": "ACTIVE",
  "photo": null,
  "groupName": "London Scala User Group",
  "groupUrlname": "london-scala",
  "scrapedAt": "2026-11-01T23:41:35.458Z"
}
```

#### Field reference (grouped by category)

| Category | Field | Coverage | Description |
|---|---|---|---|
| 🏷️ **Identity** | `type` | 🟢 High | Record type: `event`, `group` or `member`. Always present. |
| 🏷️ **Identity** | `id` | 🟢 High | Meetup numeric ID of the event / group / member. Always present. |
| 🏷️ **Identity** | `title` / `name` | 🟢 High | Event title (`title`) or group/member name (`name`). |
| 🏷️ **Identity** | `url` | 🟢 High | Direct link to the event, group or member profile. |
| 📅 **Schedule** | `eventType` / `isOnline` | 🟢 High | `ONLINE` or `PHYSICAL`, plus a convenience boolean. |
| 📅 **Schedule** | `status` | 🟢 High | Event status (e.g. `ACTIVE`, `PAST`, `CANCELLED`). |
| 📅 **Schedule** | `startDateTime` / `endDateTime` | 🟢 High | Start and end time (ISO 8601 with timezone offset). |
| 📅 **Schedule** | `durationMs` / `createdTime` | 🟢 High | Event duration (`"PT1H30M"`) and creation timestamp (ISO 8601). |
| 📝 **Content** | `description` | 🟢 High | Full event or group description text. |
| 📝 **Content** | `howToFindUs` | 🟡 Conditional | Host's "how to find us" note. *Present when provided.* |
| 📝 **Content** | `topics` / `photo` | 🟡 Conditional | Related topic tags and high-res image URL. |
| 🎟️ **Attendance & Fee** | `goingCount` / `waitlistCount` | 🟢 High | Exact number of RSVP "yes" attendees and waitlisted members. |
| 🎟️ **Attendance & Fee** | `maxTickets` / `spotsLeft` | 🟡 Conditional | Capacity and remaining spots when a limit is configured. |
| 🎟️ **Attendance & Fee** | `isFree` / `feeAmount` / `feeCurrency` | 🟡 Conditional | Free vs. paid flag, ticket price and currency. |
| 📍 **Venue & Hosts** | `hosts` | 🟢 High | Array of hosts/organizers: `name`, `memberId`, `memberUrl`. |
| 📍 **Venue & Hosts** | `venue` | 🟢 High | Venue object: `name`, `address`, `city`, `state`, `postalCode`, `country`, `lat`, `lon`. |
| 👥 **Group & Community** | `groupId` / `groupName` / `groupUrlname` / `groupUrl` | 🟢 High | The community hosting the event. |
| 👥 **Group & Community** | `groupMemberCount` / `memberCount` | 🟢 High | Total member count of the group. |
| 👥 **Group & Community** | `groupCity` / `groupCountry` / `category` | 🟢 High | Group location and topic category. |
| 👥 **Group & Community** | `foundedDate` / `joinMode` / `isPrivate` | 🟢 High | (Group) founding date, join mode, privacy status. |
| 👥 **Group & Community** | `organizerName` / `organizerUrl` | 🟢 High | (Group) primary organizer name and profile link. |
| 🧑‍💼 **Member Roles** | `isOrganizer` / `isLeader` / `isProOrganizer` | 🟢 High | (Member) community leadership role flags. |
| 🔎 **Provenance** | `searchKeyword` / `searchLocation` / `scrapedAt` | 🟢 High | Search context and ISO timestamp of extraction. |

> ℹ️ **Honesty notes.** Not every event fills every field — online events have no physical venue (they carry a placeholder `"Online event"` venue), free events have no `feeAmount`, and only tagged events have `topics`. For **member** records, Meetup now publicly exposes only a thin profile (name, role flags, membership status); fields like `bio`, `city` and `photo` are often `null`. Private contact details (email, phone) are **never** exposed by Meetup and are **never** collected — only publicly visible data is returned.

***

### 🔁 Pagination & scale

You never have to think about pages — the **Meetup scraper** handles pagination for you and returns large, de-duplicated result sets:

- **Keyword search** uses Meetup's GraphQL **cursor pagination** (`pageInfo.endCursor` / `hasNextPage`), pulling **50 events per page** and walking every page until Meetup reports no more results. A popular keyword in a big city can return **hundreds of events**; running several keywords (as in the verification run below) easily reaches the low thousands.
- **Group URLs** paginate the group's **upcoming** and **past** event lists the same way, so a single group URL can yield its **entire event history**.
- **Group members** (when `scrapeGroupMembers` is on) paginate the publicly listed membership sample 50 at a time.
- Events are **de-duplicated by event ID** across keywords and groups, so you never get the same event twice.
- The total run size is capped only by **`maxItems`** (set `0` for no limit) — use it to control cost. Leaving it at the default keeps the run bounded for a quick preview.

> ✅ **Latest verification run:** a single run searching 8 broad keywords in New York returned **450 unique events in ~43 seconds** on default datacenter proxies — **0 duplicates**, with core fields (`type`, `id`, `title`, `url`, `startDateTime`, `endDateTime`, `eventType`, `goingCount`, `status`, `groupName`) at **100%** coverage and venue data at ~92%.

***

### ⚙️ How to use the Meetup Scraper (step by step)

You don't need any technical knowledge to get started.

1. Open the Actor in the **Apify Console** and click **Try for free**.
2. Choose **one or both** of the following:
   - **Search events by keyword** – add one or more keywords (e.g. `javascript`, `yoga`, `startup networking`) and pick a **City** (or type one in the **Other city** box).
   - **Scrape specific events or groups by URL** – paste Meetup event or group URLs into **Start URLs**.
3. (Optional) Set filters: event type, date range, sort order, and a **Max items** limit to control cost.
4. Click **Start** ▶️.
5. When the run finishes, open the **Storage / Dataset** tab and **export** as JSON, CSV, Excel, HTML or XML.
6. **Automate it:** trigger the Actor from the [Apify API](https://docs.apify.com/api/v2), schedule daily/weekly runs, or wire the output into **Make, Zapier, n8n, Google Sheets, Slack or a webhook**.

***

### 💡 Tips & best practices

- **Combine keyword + location** for the most relevant results. Keyword search always needs a city; online events still appear in any city's results.
- **Use `maxItems` to control cost.** Start small (50–100) to preview the data, then scale up.
- **Run several broad keywords at once** (e.g. `technology`, `business`, `music`, `networking`) to pull a wide, de-duplicated cross-section of a city's events in one run.
- **Group URLs are the most thorough way** to collect a community's entire event history – keep `scrapeGroupEvents: true` to get both upcoming and past events.
- **For lead generation**, scrape group URLs with `scrapeGroupMembers: true` to capture organizers and engaged members (the role flags identify organizers/leaders).
- **Filter the dataset by `type`** (`event`, `group`, `member`) after export to split records into separate sheets.
- **Schedule the Actor** (daily/weekly) to keep an always-fresh event feed for your app or newsletter.

***

### 🌐 Proxy & reliability

This Actor extracts structured event and community objects directly rather than parsing fragile HTML layouts, so you get complete records with exact RSVP counts and venue coordinates. Because Meetup applies per-IP rate limiting to keyword event searches, the scraper runs on **Apify Proxy (datacenter) by default** and **automatically escalates to residential proxies** the moment a datacenter IP is throttled. On top of that, it rotates to a fresh IP on every retry and automatically re-queries empty pages on clean IPs so results stay reliable and complete. Scraping events and groups by URL is even lighter and usually stays on low-cost datacenter IPs. You can also configure residential or custom proxies in `proxyConfiguration`.

***

### ❓ Frequently asked questions

#### Do I need a Meetup API key or account?

No. This **Meetup scraper** requires no Meetup API key, OAuth token, or account login. It works entirely with publicly available data on Meetup.com — a true **Meetup API alternative**.

#### How many events can I scrape and how fast?

Search mode paginates automatically (50 records per cursor page) and returns hundreds of events per keyword/city; when you request `maxItems: 1000+`, it walks deep cursor pages and expands across topics to deliver **1,000+ unique events** in a single run. In our verification benchmark, a multi-keyword New York run pulled **450 unique events in ~43 seconds** with **0 duplicates**. Use `maxItems` to cap the total and manage cost.

#### Do I need proxies or a login?

No login, ever. The Actor uses Apify Proxy (datacenter) by default and escalates to residential automatically if Meetup throttles. You can also bring your own proxies.

#### What's the difference between search mode and URL mode?

**Search mode** (`searchQueries` + `city`/`customCity`) is best for discovery — it finds many events matching a keyword in a city. **URL mode** (`startUrls`) is best when you already know the exact events or groups you want, and it can also pull a group's full event history and a sample of members.

#### How do I search a city that isn't in the dropdown?

Use the **`customCity`** field (the "Other city" box). Type any location — e.g. `Lisbon`, `Denver, USA`, `Cape Town` — and it is geocoded automatically. `customCity` always overrides the `city` dropdown.

#### Can I filter by event type, date or sort order?

Yes. Use `eventType` (`any` / `online` / `physical`), `dateRange` (today, this-week, this-month, etc.) and `sortBy` (`relevance` or `date`).

#### Can I get attendee or member email addresses?

No. Meetup does not publicly expose email addresses or phone numbers, so they are never collected. Member records return only public data (name, role flags, membership status; `bio`/`city`/`photo` when Meetup still shows them).

#### Why are some fields empty?

Not every event or group fills in every field on Meetup — online events have no physical venue, free events have no fee, untagged events have no `topics`, and Meetup now shows only a thin public member profile. Empty fields simply mean the data isn't published on Meetup.

#### How fresh is the data and is there an API?

The scraper fetches **live data** from Meetup.com on every run, so results reflect the current state of the site. You can call it from any language via the **Apify API**, schedule it, or trigger it from a webhook — making it a reliable programmatic **Meetup API**.

#### In what formats can I download the data?

JSON, CSV, Microsoft Excel (XLSX), HTML table, and XML — plus direct access via the Apify API and dataset views.

***

### 🔌 Integrations & automation

This Meetup Scraper plugs straight into your stack: the **Apify API** and **webhooks** for programmatic access, **Zapier / Make / n8n** to push results into thousands of apps, **Google Sheets / Slack / Airtable / Gmail** to deliver data where your team works, **MCP / AI agents** to use it as an LLM tool, and the **Scheduler** for daily, weekly or custom runs.

#### Using the Meetup Scraper via API

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
    "searchQueries": ["data science"],
    "city": "San Francisco",
    "eventType": "any",
    "maxItems": 100,
}

run = client.actor("haketa/meetup-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], "-", item.get("goingCount"), "going")
```

A JavaScript/Node client (`apify-client`) works the same way — call `client.actor('haketa/meetup-scraper').call(input)` and read `defaultDatasetId`.

***

### 🔗 Related scrapers

Building an events, travel or lead-generation pipeline? Pair the **Meetup scraper** with these other Actors:

- [Luma Event Scraper](https://apify.com/haketa/luma-event-scraper) — extract events, hosts and attendee data from **Luma (lu.ma)**.
- [Eventbrite Scraper](https://apify.com/haketa/eventbrite-scraper) — scrape **Eventbrite** events, organizers, dates, venues and ticket prices.
- [Expedia Scraper](https://apify.com/haketa/expedia-scraper) — pull **Expedia** hotel listings, prices and reviews for travel and event logistics.
- [HRS Scraper](https://apify.com/haketa/hrs-scraper) — collect **HRS** hotel rates and availability for business-travel and event planning.
- [Furnished Finder Scraper](https://apify.com/haketa/furnishedfinder-scraper) — scrape **Furnished Finder** mid-term rental listings and landlord contacts.
- [Yachtall Scraper](https://apify.com/haketa/yachtall-scraper) — extract **Yachtall** boat and yacht listings with prices and specs.

***

### 🛟 Support & feedback

Found a bug, missing a field, or need a new feature? Open an issue on the Actor's **Issues** tab — feedback is very welcome. If an event or group fails to scrape, please include the exact URL so it can be reproduced.

***

### 🏷️ Keywords

Meetup scraper, Meetup.com scraper, scrape Meetup, Meetup events scraper, Meetup group scraper, Meetup data extractor, Meetup API, Meetup API alternative, extract Meetup events, Meetup event data, Meetup group data, Meetup members scraper, Meetup organizer data, event scraper, community data, lead generation, B2B intelligence, event marketing, networking events, RSVP data, event aggregator, 1,000+ results pagination, bulk export JSON CSV Excel API.

***

### 📋 Changelog

| Version | Date | Highlights |
|---|---|---|
| **v1.2** | **2026-11** | Unlocked **1,000+ deep pagination** across cursor pages and multi-topic expansion when `maxItems >= 1000`, tuned prefill to 50 items for sub-30s startup verification, and enhanced status reporting before exit. |
| **v1.1** | **2026-11** | Re-verified against live Meetup data (450 unique events in ~43s, 0 duplicates, 100% core field coverage); refreshed output examples and field coverage reference. |
| **v1.0** | **2026-05** | Initial release — keyword + city search, direct event/group URL extraction, automatic city geocoding, and datacenter-to-residential proxy escalation. |

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/meetup-scraper/changelog.md

# Actor input Schema

## `searchQueries` (type: `array`):

Topics to look for on Meetup.com (e.g. "javascript", "yoga", "startup networking"). Each keyword is searched separately in the chosen city. Leave empty to get a ready-made mix of popular events for the selected city.

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

Pick a city to search events in. Keyword search always runs against a city, and online events also appear in every city's results. Need a city that is not in this list? Use the "Other city" box below.

## `customCity` (type: `string`):

Any city not in the list above (e.g. "Lisbon", "Denver, USA", "Cape Town"). When filled, this overrides the City dropdown. The city is located automatically, no coordinates needed.

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

Filter keyword searches by how the event is held.

## `dateRange` (type: `string`):

Restrict keyword search results to a time window. Applies to upcoming events only.

## `sortBy` (type: `string`):

Order in which keyword search results are collected.

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

Optional. Already know exactly which events or communities you want? Paste direct Meetup.com URLs to scrape specific <b>event</b> pages (e.g. <code>https://www.meetup.com/some-group/events/123456789/</code>) or <b>group</b> pages (e.g. <code>https://www.meetup.com/some-group/</code>). Group URLs can also pull the group's upcoming/past events and a sample of members (see toggles below). Works with or without the keyword search above.

## `scrapeGroupEvents` (type: `boolean`):

When a Start URL points to a group page, also collect that group's upcoming and recent past events as separate event records.

## `scrapeGroupMembers` (type: `boolean`):

When a Start URL points to a group page, also extract the publicly listed sample of group members and organizers (useful for lead generation and community research).

## `includeFullEventDetails` (type: `boolean`):

Visit each event found via keyword search to collect the complete description, host details, exact venue coordinates and metadata. More accurate but uses one extra request per event (slower & slightly more expensive). When off, the rich data already returned by the search is used.

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

Maximum number of output records (events + groups + members) to scrape across the whole run. Use this to control cost. Set 0 for no limit.

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

Maximum number of pages scraped in parallel. Lower this if you hit rate limits; raise it for faster large runs.

## `maxRequestRetries` (type: `integer`):

How many times a failed request is retried before being marked as failed.

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

Proxy settings. Datacenter by default (low-cost); auto-escalates to residential if blocked. You can also select residential or your own proxies.

## Actor input object example

```json
{
  "searchQueries": [
    "technology"
  ],
  "city": "New York",
  "customCity": "Lisbon",
  "eventType": "any",
  "dateRange": "any",
  "sortBy": "relevance",
  "startUrls": [
    {
      "url": "https://www.meetup.com/london-scala/"
    }
  ],
  "scrapeGroupEvents": true,
  "scrapeGroupMembers": false,
  "includeFullEventDetails": false,
  "maxItems": 50,
  "maxConcurrency": 10,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All extracted records (events, groups and members) for this run.

## `overviewTable` (type: `string`):

A clean, human-readable table view of the scraped records.

# 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 = {
    "searchQueries": [
        "technology"
    ],
    "startUrls": [
        {
            "url": "https://www.meetup.com/london-scala/"
        }
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/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 = {
    "searchQueries": ["technology"],
    "startUrls": [{ "url": "https://www.meetup.com/london-scala/" }],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/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 '{
  "searchQueries": [
    "technology"
  ],
  "startUrls": [
    {
      "url": "https://www.meetup.com/london-scala/"
    }
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/meetup-scraper --silent --output-dataset

```

## MCP server setup

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