# Meetup Events Scraper (`automation-lab/meetup-scraper`) Actor

Scrape Meetup.com events from search results. Get event titles, dates, venues, groups, RSVP counts, descriptions, and ticket info.

- **URL**: https://apify.com/automation-lab/meetup-scraper.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Social media, Lead generation
- **Features:** Limited permissions
- **Stats:** 23 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 4.00 out of 5 stars

## Pricing

from $3.00 / 1,000 event extracteds

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

Scrape Meetup.com events from search results. Get event titles, dates, venues, group names, RSVP counts, descriptions, and ticket details as structured JSON data.

### What does Meetup Events Scraper do?

This actor searches Meetup.com and extracts event data from search results, including:

- **Event details** — title, date/time, type (in-person/online), full description
- **Venue info** — name, address, city, state, country
- **Group info** — group name, URL, rating, total ratings
- **Attendance** — RSVP count, max tickets
- **Pricing** — free/paid status, fee amount and currency
- **Media** — event cover image URL

The actor uses Meetup's built-in location geocoding, so you can search by city name (e.g., "New York", "London", "Tokyo") without needing exact coordinates.

### Who is it for?

Use Meetup Events Scraper if you research local events, build community lead lists, monitor meetups by topic, or enrich event calendars for marketing and partnerships.

### Why use Meetup Events Scraper?

- **No API key needed** — extracts data directly from Meetup's public search pages
- **Automatic geocoding** — converts city names to Meetup's location format
- **Clean, structured output** — all fields are normalized and ready for analysis
- **Fast and lightweight** — no browser needed, runs on minimal memory
- **Filter support** — narrow results by event type (in-person/online) and date range
- **Multi-search batches** — monitor up to 10 topic/location combinations in one Task and get one deduplicated dataset

### How to scrape Meetup events

1. Go to [Meetup Events Scraper](https://apify.com/automation-lab/meetup-scraper) on Apify Store.
2. For one search, enter a keyword in `searchQuery` (e.g., "python" or "startup networking").
3. To run several searches, instead provide a `searches` array with up to 10 search objects.
4. Optionally set a `location`, `eventType`, `dateRange`, and `maxResults` for each search.
5. Click **Start** and wait for the run to finish.
6. Download the deduplicated event data as JSON, CSV, or Excel from the **Dataset** tab.

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

Meetup Events Scraper uses the pay-per-event pricing model:

| Event | Price |
|-------|-------|
| Actor start | $0.001 |
| Per event extracted | $0.005 |

**Cost examples:**

| Scenario | Events | Estimated cost |
|----------|--------|----------------|
| Quick search | 10 | ~$0.051 |
| Full page | 25 | ~$0.126 |

Platform costs (compute and memory) are additional but minimal — a typical run uses under $0.003 in platform costs.

### Input parameters

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| `searchQuery` | string | Search term (e.g., "python", "hiking", "startup networking") | *Required* |
| `location` | string | City name (e.g., "New York", "London"). Leave empty for global | Empty |
| `eventType` | string | Filter: `inPerson`, `online`, or empty for all | All types |
| `dateRange` | string | Filter: `today`, `tomorrow`, `this-week`, `this-weekend`, `next-week` | Any time |
| `maxResults` | integer | Maximum events to extract (1–30) | 25 |
| `searches` | array | Optional 1–10 search objects. Replaces the top-level single-search fields when provided; combined `maxResults` cannot exceed 100 | Empty |

#### Batch multiple searches

Use `searches` to monitor several combinations in one scheduled Task:

```json
{
  "searches": [
    {
      "searchQuery": "python programming",
      "location": "New York",
      "dateRange": "this-week",
      "maxResults": 20
    },
    {
      "searchQuery": "startup networking",
      "location": "London",
      "eventType": "inPerson",
      "maxResults": 20
    }
  ]
}
```

Events returned by more than one search are saved once. Their `sourceSearches` array lists every matching configured search.

### Output example

Each event in the dataset looks like this:

```json
{
  "eventId": "313520522",
  "title": "AgentCon NYC",
  "dateTime": "2026-03-09T09:00:00-04:00",
  "eventType": "PHYSICAL",
  "eventUrl": "https://www.meetup.com/nycneo4j/events/313520522/",
  "description": "Join us for the AI Agents World Tour, a global series of one-day conferences...",
  "rsvpCount": 85,
  "maxTickets": 0,
  "venueName": "Nasdaq",
  "venueAddress": "151 W 42nd St",
  "city": "New York",
  "state": "NY",
  "country": "us",
  "groupName": "Graph Database New York",
  "groupUrlname": "nycneo4j",
  "groupRating": 4.6,
  "groupTotalRatings": 121,
  "imageUrl": "https://secure.meetupstatic.com/photos/event/highres_532911297.jpeg",
  "isFree": true,
  "feeAmount": null,
  "feeCurrency": "",
  "searchQuery": "AI agents",
  "sourceSearches": [
    {
      "searchIndex": 0,
      "searchQuery": "AI agents",
      "location": "New York",
      "eventType": "",
      "dateRange": "this-week"
    }
  ],
  "scrapedAt": "2026-03-03T07:14:10.790Z"
}
```

### API usage

#### Node.js

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

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

const run = await client.actor('automation-lab/meetup-scraper').call({
    searches: [
        { searchQuery: 'python programming', location: 'New York', maxResults: 20 },
        { searchQuery: 'startup networking', location: 'London', maxResults: 20 },
    ],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((event) => {
    console.log(`${event.title} — ${event.dateTime} (${event.rsvpCount} RSVPs)`);
});
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("automation-lab/meetup-scraper").call(run_input={
    "searchQuery": "python programming",
    "location": "New York",
    "maxResults": 20,
})

for event in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{event['title']} — {event['dateTime']} ({event['rsvpCount']} RSVPs)")
```

### Use cases

- **Event discovery** — find relevant meetups and conferences in any city by keyword
- **Community research** — analyze the tech/startup scene in different locations
- **Competitive intelligence** — monitor events from specific groups or industries
- **Content planning** — find speaking opportunities and networking events
- **Market research** — track trends in event topics and attendance patterns
- **Lead generation** — identify events where your target audience gathers

### Event types

| Value | Description |
|-------|-------------|
| `PHYSICAL` | In-person events with a physical venue |
| `ONLINE` | Virtual events (video/audio) |

### Integrations

Connect Meetup Events Scraper with other tools using Apify integrations:

- **Google Sheets** — export event data for tracking and planning
- **Slack/Email** — get notified when new events match your criteria
- **Webhooks** — trigger workflows when new events are found
- **Zapier/Make** — connect event data to 5,000+ apps
- **API** — schedule regular event monitoring runs

### Tips for best results

1. **Use specific keywords** — "python machine learning" returns more relevant results than "tech"
2. **Specify a location** — location-based searches return more targeted results
3. **Try different date ranges** — "this-week" gives immediate events, no filter gives broader results
4. **Combine with other scrapers** — pair with Eventbrite Scraper for comprehensive event coverage
5. **Online vs in-person** — filter by event type to focus on your preferred format

### Data source

All data comes from Meetup.com's public search pages. The actor extracts structured data from the page's embedded Apollo GraphQL state, which contains complete event information including descriptions, venues, groups, and RSVP counts.

### Use with AI agents via MCP

Meetup Scraper is available as a tool for AI assistants via the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/meetup-scraper"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/meetup-scraper"
        }
    }
}
```

#### Example prompts

- "Find Python meetups in New York City"
- "Search Meetup for tech events near me"
- "What AI and machine learning meetups are happening in San Francisco this week?"

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~meetup-scraper/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQuery": "python programming",
    "location": "New York",
    "maxResults": 20
  }'
```

### Legality

Scraping publicly available data is generally legal according to the [US Court of Appeals ruling](https://en.wikipedia.org/wiki/HiQ_Labs_v._LinkedIn) (HiQ Labs v. LinkedIn). This actor only accesses publicly available information and does not require authentication. Always review and comply with the target website's Terms of Service before scraping. For personal data, ensure compliance with GDPR, CCPA, and other applicable privacy regulations.

### FAQ

**The scraper returns events from unexpected locations.**
Meetup's search uses geocoding to convert city names to coordinates and then searches a radius around that point. If your city name is ambiguous (e.g., "Portland" could be Oregon or Maine), try being more specific (e.g., "Portland, OR"). Leaving the location empty searches globally.

**Why am I only getting ~25 results maximum?**
Meetup's server-side search caps results at approximately 25 events per query. This is a Meetup platform limitation, not a scraper limitation. To get more events, try different search keywords or date range filters.

### Limitations

- Returns up to ~25 events per search (Meetup's server-side search result limit)
- Batch runs support up to 10 searches and 100 combined requested results
- Searches run sequentially to keep Meetup request load and memory usage bounded
- Event descriptions may be truncated to 2,000 characters
- Location search uses Meetup's built-in geocoding — use common city names for best results
- Some online events may not have venue/city information

### Related actors

- [Eventbrite Scraper](https://apify.com/automation-lab/eventbrite-scraper) -- scrape events, venues, and ticket details from Eventbrite

# Changelog

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

# Actor input Schema

## `searchQuery` (type: `string`):

Search term for a single search (e.g. "python", "hiking", "startup networking"). Required unless searches is provided.

## `location` (type: `string`):

Location for a single search (e.g. "New York", "San Francisco", "London"). Leave empty for global results.

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

Filter a single search by event format.

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

Filter a single search by when events are happening.

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

Maximum events to extract for a single search (1–30). Meetup returns up to ~25 events per search.

## `searches` (type: `array`):

Optional list of 1–10 searches. When provided, these replace the top-level single-search fields. The combined maxResults must not exceed 100.

## Actor input object example

```json
{
  "searchQuery": "python programming",
  "location": "New York",
  "eventType": "",
  "dateRange": "",
  "maxResults": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Dataset containing all unique Meetup events.

# 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 = {
    "searchQuery": "python programming",
    "location": "New York"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "searchQuery": "python programming",
    "location": "New York",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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 '{
  "searchQuery": "python programming",
  "location": "New York"
}' |
apify call automation-lab/meetup-scraper --silent --output-dataset

```

## MCP server setup

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