# Meetup Events Scraper (`parsebird/meetup-events-scraper`) Actor

Scrape Meetup.com events and groups by city, keyword, or coordinates. Extract dates, venues, RSVP counts, fees, group ratings, and organizer contacts for lead generation. Export JSON, CSV, Excel via API.

- **URL**: https://apify.com/parsebird/meetup-events-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.39 / 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 Events Scraper - Events, Groups & RSVP Data

Meetup Events Scraper extracts events and groups from [Meetup.com](https://www.meetup.com) — search by city, keyword, or exact coordinates and get dates, venues, RSVP counts, fees, topics, group ratings, and organizer contact details.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">Search events or groups by keyword, city, event type, radius, date range, and minimum RSVP count — get structured data plus organizer contacts for outreach, and optionally push results straight into Notion or Slack.</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

```
parsebird/meetup-events-scraper on Apify. Call: ApifyClient("TOKEN").actor("parsebird/meetup-events-scraper").call(run_input={"mode":"events","searchKeyword":"artificial intelligence","city":"Berlin","country":"de","eventType":"PHYSICAL","minRsvpCount":20,"sortBy":"DATETIME","maxResults":100}), then client.dataset(run["defaultDatasetId"]).list_items().items for results. Key inputs: mode (events|groups, default events), searchKeyword (required for groups; empty in events mode browses all upcoming events nearby), city/state/country (geocoded automatically) or lat/lon (skips geocoding), eventType (PHYSICAL|ONLINE|HYBRID|any, events only), radius (miles), startDateRange/endDateRange (ISO 8601), minRsvpCount (events only), sortBy (RELEVANCE|DATETIME, events only), maxResults (0 = unlimited, required), outputConnectors (optional MCP connectors like Notion/Slack, authorized in Apify Console). Event records have eventId/eventName/startDateTime/endDateTime/timezone/actualAttendees/isPaidEvent/eventUrl/venue/group/topics/ratingAverage/ratingCount/reviewCount plus v1-compatible flat fields (date, address, organizedByGroup, feeCurrency, going). Group records have groupName/groupUrl/memberCount/category/organizerName/organizerProfileUrl/socialLinks/ratingAverage/reviewCount/city/country/foundedDate. Full actor spec: GET https://api.apify.com/v2/acts/parsebird~meetup-events-scraper (Bearer TOKEN). Get token: https://console.apify.com/account/integrations
```

### What is Meetup Events Scraper?

Meetup Events Scraper is an [Apify Actor](https://apify.com/actors) that acts as a **Meetup API alternative** — Meetup retired its public v3 REST API, so this actor reads the same GraphQL data Meetup's own website uses to power its search results, and returns it as clean structured rows. Search any city worldwide by name (geocoded automatically, including non-English names) or by exact coordinates, filter by keyword, event type, date range, and RSVP count, and get results ready for analysis or outreach.

Use it as a **Meetup scraper**, an **event discovery API**, or a **lead generation tool** for community and group organizers, event marketers, and researchers. Results download as JSON, CSV, Excel, XML, or HTML, or you can pull them programmatically through the [Apify API](https://docs.apify.com/api/v2), or push them directly into Notion or Slack with output connectors.

### What can Meetup Events Scraper do?

- 📅 Search **upcoming events** by keyword, or browse all upcoming events near a location when no keyword is given
- 👥 Search **groups** by keyword for lead generation — organizer names, profile URLs, and social links included
- 🌍 Search any **city worldwide** by name (auto-geocoded, including non-English names) or by exact latitude/longitude
- 🎯 Filter by **event type** (in-person, online, hybrid), search radius, date range, and minimum RSVP count
- 💰 Get **fee details** (amount, currency) and paid/free status for every event
- ⭐ Get **group ratings** — average rating, rating count, and review count (public Meetup data since 2025)
- 📤 Push results directly into **Notion or Slack** with optional MCP output connectors
- ⚙️ Run on demand, schedule recurring runs, or connect results to Apify [integrations](https://apify.com/integrations) like Google Sheets, Zapier, Make, and webhooks
- 📊 Export data in JSON, CSV, Excel, XML, RSS, or HTML from the Apify dataset

### What data can you extract from Meetup?

| Data point | Description |
|------------|-------------|
| Event | Name, description, type (in-person / online / hybrid), status, URL, cover photo |
| Date & time | Start, end, duration, and IANA time zone (correct local times worldwide) |
| Venue | Name, address, city, country, postal code, and GPS lat/lon |
| Attendance & fees | RSVP count, capacity, paid/free flag, fee amount, currency |
| Group & organizer | Group name, URL, member count, category; organizer name + profile URL; social links |
| Ratings & topics | Average rating, rating & review counts (public since 2025); topic tags |

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `mode` | string | No | `events` | `events` or `groups` |
| `searchKeyword` | string | Depends\* | — | Keyword to search. Required for `groups` |
| `city` | string | No\*\* | — | City to search, geocoded automatically |
| `state` | string | No | — | Optional region to disambiguate the city, e.g. `CA` |
| `country` | string | No | — | 2-letter country code. Note: the UK is `gb` |
| `lat` / `lon` | string | No\*\* | — | Optional exact coordinates — provide both to skip geocoding |
| `eventType` | string | No | `any` | `PHYSICAL`, `ONLINE`, `HYBRID`, or `any`. Events mode only |
| `radius` | integer | No | — | Search radius in miles |
| `startDateRange` / `endDateRange` | string | No | — | ISO 8601 bounds. Upcoming only — a past start is treated as now |
| `minRsvpCount` | integer | No | — | Minimum RSVP count. Events mode only |
| `sortBy` | string | No | `RELEVANCE` | `RELEVANCE` or `DATETIME` (soonest first). Events mode only |
| `maxResults` | integer | **Yes** | `50` | Maximum results. `0` = unlimited |
| `outputConnectors` | array | No | — | Optional MCP connectors (Notion, Slack, …), authorized in Apify Console |
| `notionParentPageUrl` | string | No | — | Notion connectors: page to create the results table under |
| `messageChannel` | string | No | — | Messaging connectors: channel to post to, e.g. `#events` |
| `connectorDelivery` | string | No | `summary` | `summary` (one message per run) or `perItem` (one per result) |
| `connectorTool` / `connectorArguments` | string / object | No | — | Advanced: force a specific connector tool / merge extra static arguments |
| `proxyConfiguration` | object | No | disabled | Optional Apify Proxy configuration |

\*Required for `groups` mode; optional for `events` (empty browses all upcoming events nearby).
\*\*Provide either `city` (+ optional `state`/`country`) or both `lat` and `lon`.

**Example input — scrape Meetup events:**

```json
{
  "mode": "events",
  "searchKeyword": "artificial intelligence",
  "city": "Berlin",
  "country": "de",
  "eventType": "PHYSICAL",
  "minRsvpCount": 20,
  "sortBy": "DATETIME",
  "maxResults": 100
}
```

**Example input — scrape Meetup groups for leads:**

```json
{
  "mode": "groups",
  "searchKeyword": "artificial intelligence",
  "city": "New York",
  "country": "us",
  "maxResults": 50
}
```

### Output example

**Event** (events mode):

```json
{
  "eventId": "316242642",
  "eventName": "Beyond Technology: AI & Data for the Common Good",
  "eventType": "PHYSICAL",
  "startDateTime": "2026-09-17T17:30:00+02:00",
  "endDateTime": "2026-09-17T21:00:00+02:00",
  "timezone": "Europe/Berlin",
  "actualAttendees": 126,
  "isPaidEvent": false,
  "eventUrl": "https://www.meetup.com/women-in-big-data-berlin-meetup-group/events/316242642/",
  "venue": { "name": "Bertelsmann Stiftung", "city": "Berlin", "country": "de", "lat": 52.51589, "lon": 13.39797 },
  "group": { "name": "Women in Big Data Berlin Meetup Group", "memberCount": 1825, "organizerName": "Women in Big Data Berlin", "organizerProfileUrl": "https://www.meetup.com/members/371218952/" },
  "topics": [{ "name": "Artificial Intelligence", "urlkey": "artificial-intelligence" }],
  "ratingAverage": 4.75,
  "ratingCount": 116,
  "reviewCount": 219
}
```

`ratingAverage`/`ratingCount`/`reviewCount` reflect the hosting group's public ratings. Backward-compatible flat fields (`eventId`, `date`, `address`, `organizedByGroup`, `feeCurrency`, `going`, and more) are included alongside the nested `venue`/`group`/`topics` objects.

**Group** (groups mode):

```json
{
  "groupName": "ARTIFICIAL INTELLIGENCE",
  "groupUrl": "https://www.meetup.com/meetup-group-aYMKMziu",
  "memberCount": 523,
  "category": "Technology",
  "organizerName": "Arash Hosseini Jafari",
  "organizerProfileUrl": "https://www.meetup.com/members/263389589/",
  "ratingAverage": 4.8,
  "ratingCount": 15,
  "reviewCount": 25,
  "city": "Los Angeles",
  "state": "CA",
  "country": "us",
  "foundedDate": "2020-01-13T13:43:40-08:00"
}
```

`socialLinks` (Facebook, LinkedIn, Instagram, and more) appear on groups that have them set. Download results in JSON, HTML, CSV, or Excel from the dataset page, or fetch rows programmatically through the API.

### How to scrape Meetup events and groups

1. Open Meetup Events Scraper on Apify and click **Try for free**.
2. Choose `mode` (events or groups) and enter a `searchKeyword` (required for groups).
3. Enter a `city` (+ optional `state`/`country`) or exact `lat`/`lon` coordinates.
4. Adjust `eventType`, `radius`, date range, `minRsvpCount`, and `sortBy` as needed.
5. Set `maxResults` (0 for unlimited) and start the run.
6. Download results as JSON, CSV, Excel, HTML, XML, or RSS, or open them straight in Google Sheets.
7. Optionally add `outputConnectors` to push results into Notion or Slack, or automate the run with [Apify scheduling](https://docs.apify.com/platform/schedules) or the [Apify API](https://docs.apify.com/api/v2).

### How to use the Meetup API in Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("parsebird/meetup-events-scraper").call(run_input={
    "mode": "events",
    "searchKeyword": "artificial intelligence",
    "city": "Berlin",
    "country": "de",
    "eventType": "PHYSICAL",
    "minRsvpCount": 20,
    "sortBy": "DATETIME",
    "maxResults": 100,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items[:2])
```

### How to use the Meetup API in JavaScript

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('parsebird/meetup-events-scraper').call({
    mode: 'groups',
    searchKeyword: 'artificial intelligence',
    city: 'New York',
    country: 'us',
    maxResults: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use cases

- **Event discovery** — Find upcoming meetups on a topic in any city, sorted by date or relevance
- **Lead generation** — Search groups by keyword to build a list of organizers and communities to reach out to
- **Community research** — Compare group sizes, ratings, and activity across cities or topics
- **Marketing intelligence** — Track paid vs. free events, typical RSVP counts, and fee ranges for a niche
- **Workflow automation** — Push new matching events or groups straight into a Notion database or Slack channel

### How it works

1. Resolves your `city`/`state`/`country` to coordinates (or uses your exact `lat`/`lon` directly, skipping geocoding)
2. Queries Meetup's event or group search with your keyword and filters (event type, radius, date range, RSVP count) applied server-side
3. Paginates through results, deduplicating by ID, until `maxResults` is reached or coverage plateaus
4. Normalizes each event or group into a structured record, including venue, group, organizer, topic, and rating details
5. Pushes records to the dataset and, if `outputConnectors` are configured, delivers them to your connected Notion page or messaging channel

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

Meetup Events Scraper uses pay-per-event pricing — you pay per event or group record saved to the dataset.

| Event | Price per event | Price per 1,000 |
|-------|-----------------|-----------------|
| `result-scraped` | $0.00099 (Free) / $0.00079 (Bronze) / $0.00059 (Silver) / $0.00039 (Gold) | **$0.99 / $0.79 / $0.59 / $0.39** |

A 100-event search run costs about $0.10 on the Free plan.

### Is it legal to scrape Meetup data?

Meetup Events Scraper extracts publicly available event and group listings from the same data Meetup's own website uses to render its search results. Scraping publicly accessible data is generally lawful, but you're responsible for how you use the results — always review [Meetup's Terms of Service](https://www.meetup.com/terms/) and Apify's guide on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) before running large or automated workloads.

### FAQ

**Do I need a Meetup account or API key?**
No. Meetup retired its public v3 REST API. This actor reads the same data Meetup's own website uses to render search results, so no credentials are required.

**Why is `searchKeyword` required for groups but optional for events?**
Leaving `searchKeyword` empty in events mode switches to Meetup's "browse nearby" feed of all upcoming events near your location. Groups don't have an equivalent browse-all endpoint, so a keyword is required.

**How does city geocoding work, and what if my city name isn't in English?**
The actor geocodes `city` (+ optional `state`/`country`) via OpenStreetMap, which handles non-English and non-Latin city names. If geocoding fails or is ambiguous, add `state` to disambiguate, or provide exact `lat`/`lon` to skip geocoding entirely.

**How do I use `outputConnectors`?**
First authorize a connector (Notion, Slack, and others) in Apify Console under Settings → Integrations, then select it in the `outputConnectors` field. The actor auto-detects a matching tool on the connector; use `connectorTool`/`connectorArguments` to override the tool name or arguments if your connector's schema differs from the default.

**Can I schedule recurring runs?**
Yes. Use [Apify scheduling](https://docs.apify.com/platform/schedules) to run daily, weekly, or at any interval, then connect the dataset to integrations, webhooks, or output connectors.

**Does this actor require a proxy?**
No. Meetup's public search data doesn't require a proxy for normal use. The `proxyConfiguration` input is available if you want extra reliability.

**How do I report a problem or request a field?**
Open an issue from the Actor page in Apify Console and include the run ID and input used.

# Changelog

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

# Actor input Schema

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

Search for events or for groups (useful for lead generation).

## `searchKeyword` (type: `string`):

Keyword to search. Leave empty in Events mode to browse all upcoming events nearby. Required in Groups mode.

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

City to search. Geocoded automatically, including non-English names (e.g. München).

## `state` (type: `string`):

Optional region to disambiguate the city, e.g. CA for California.

## `country` (type: `string`):

2-letter country code. Note: the UK is gb.

## `lat` (type: `string`):

Optional exact latitude. Provide both lat and lon to skip geocoding.

## `lon` (type: `string`):

Optional exact longitude. Provide both lat and lon to skip geocoding.

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

Filter by event format. Events mode only.

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

Search radius in miles around the location.

## `startDateRange` (type: `string`):

ISO 8601 lower bound for event start times. Upcoming only — a past date is treated as now.

## `endDateRange` (type: `string`):

ISO 8601 upper bound for event start times.

## `minRsvpCount` (type: `integer`):

Only return events with at least this many RSVPs. Events mode only.

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

Result ordering. Events mode only.

## `maxResults` (type: `integer`):

Maximum number of results to collect. 0 = unlimited.

## `outputConnectors` (type: `array`):

Optional MCP connectors (Notion, Slack, and more) to push results into. Authorize them first in Apify Console under Settings → Integrations.

## `notionParentPageUrl` (type: `string`):

For Notion connectors: the page to create the results table under. Columns are built automatically.

## `messageChannel` (type: `string`):

For messaging connectors (e.g. Slack): the channel to post to, such as #events.

## `connectorDelivery` (type: `string`):

For messaging connectors: send one summary message per run, or one message per result.

## `connectorTool` (type: `string`):

Advanced: force a specific MCP tool name instead of auto-detecting one.

## `connectorArguments` (type: `object`):

Advanced: static arguments merged into every connector tool call.

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

Optional Apify Proxy configuration for collection reliability.

## Actor input object example

```json
{
  "mode": "events",
  "searchKeyword": "artificial intelligence",
  "city": "Berlin",
  "state": "",
  "country": "",
  "lat": "",
  "lon": "",
  "eventType": "any",
  "sortBy": "RELEVANCE",
  "maxResults": 50,
  "outputConnectors": [],
  "notionParentPageUrl": "",
  "messageChannel": "",
  "connectorDelivery": "summary",
  "connectorTool": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "events",
    "searchKeyword": "artificial intelligence",
    "city": "Berlin",
    "eventType": "any",
    "sortBy": "RELEVANCE",
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/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",
    "searchKeyword": "artificial intelligence",
    "city": "Berlin",
    "eventType": "any",
    "sortBy": "RELEVANCE",
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/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",
  "searchKeyword": "artificial intelligence",
  "city": "Berlin",
  "eventType": "any",
  "sortBy": "RELEVANCE",
  "maxResults": 50
}' |
apify call parsebird/meetup-events-scraper --silent --output-dataset

```

## MCP server setup

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