# Meetup Event Scraper (`datapilot/meetup-event-scraper`) Actor

. Extracts event title, date, location, and URL, then outputs structured JSON for event discovery, lead generation, and trend monitoring. 🎤📅

- **URL**: https://apify.com/datapilot/meetup-event-scraper.md
- **Developed by:** [Data Pilot](https://apify.com/datapilot) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 scraped results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

🎉 **Meetup Event** Scraper is a powerful Apify Actor designed to discover, track, and collect local and virtual event data directly from Meetup's own event search pages using a real headless browser. This tool provides comprehensive **Meetup Event** intelligence including event name, event date, location, and a direct link to the event page for any search keyword. Whether you're building a local events dashboard, tracking community activity, or conducting market research, the Meetup Event Scraper delivers actionable **Meetup Event** insights efficiently.

With real browser rendering, multi-strategy page-load handling, scroll-triggered content loading, retry-resilient scraping, and reliable Apify Dataset delivery, the Meetup Event Scraper ensures comprehensive **Meetup Event** coverage across any list of search keywords. It focuses on key **Meetup Event** signals including event date, location, and title, making it an essential tool for community and event research.

***

### 📋 Table of Contents

- [Features](#-features)
- [Data Source](#-data-source)
- [How It Works](#-how-it-works)
- [Input](#-input)
- [Output](#-output)
- [Technical Stack](#-technical-stack)
- [Data Fields](#-data-fields-explained)
- [Use Cases](#-use-cases)
- [Quick Start](#-quick-start)
- [Configuration](#-configuration)
- [Performance](#-performance)
- [Important Notes](#-important-notes)
- [License & Legal](#-license--legal)

***

### 🔥 Features

- **Real Browser Rendering** – Uses  (Chromium) to load Meetup's event search results exactly as a real visitor would see them.
- **Multi-Strategy Page Loading** – Tries several navigation wait strategies (`domcontentloaded`, `load`, `commit`) in sequence to maximize successful page loads.
- **Automation Detection Evasion** – Masks the `navigator.webdriver` flag and rotates user agents to reduce the chance of bot detection.
- **Scroll-Triggered Content Loading** – Automatically scrolls the page multiple times to load additional **Meetup Event** listings.
- **Retry-Resilient Scraping** – Automatically retries an entire scrape attempt up to 3 times with increasing backoff on failure.
- **Stable Event ID Generation** – Builds a consistent numeric event ID by hashing each event's URL.
- **Date & Location Extraction** – Attempts to pull event date/time and venue/location text from each event's surrounding page context.
- **Deduplication** – Filters out duplicate event links within a single scrape.
- **Residential Proxy Support** – Apify residential proxy for reliable **Meetup Event** access.
- **Multi-Keyword Batch Processing** – Scrape events for any number of comma-separated keywords in a single run.
- **Real-Time Dataset Push** – Pushes each keyword's **Meetup Event** results to Apify Dataset as they're collected.

***

### 📊 Data Source

#### **Meetup Public Event Search Pages**

- **Authority**: Meetup's own public-facing event search results (`meetup.com/find/?keywords=...`)
- **Access Method**: Headless Chromium via , with automation-detection evasion
- **Coverage**: Any publicly listed **Meetup Event** matching the given search keyword
- **Data**: Event links, titles, and any date/location text visible in the rendered page's surrounding elements
- **Access**: Public search results, no API key required
- **Update Frequency**: Reflects Meetup's current live search results at time of run

***

### ⚙️ How It Works

The Meetup Event Scraper accepts one or more comma-separated keywords and, for each one, launches a headless Chromium browser to load Meetup's event search results page. To maximize reliability, it tries multiple page-load wait strategies in sequence and waits for event links to appear before proceeding. The Actor then scrolls the page three times to trigger additional event listings to load. Every event link on the page is extracted, deduplicated, and paired with any visible date and location text found in its surrounding page context. Each event record includes a stable ID generated by hashing its URL. The full scrape attempt is retried up to three times with backoff if any step fails. Results for each keyword are pushed to the Apify Dataset as a single record containing the keyword's event list and summary status.

**Key Processing Steps:**

1. **Input Parsing** – Accept comma-separated keywords and a max events-per-keyword count
2. **Proxy Setup** – Configure Apify residential proxy for the browser session
3. **Keyword Loop** – Iterate through each **Meetup Event** search keyword
4. **Browser Launch** – Start a headless Chromium instance with a randomized user agent and evasion flags
5. **Multi-Strategy Navigation** – Attempt page load with several wait strategies until one succeeds
6. **Event Link Wait** – Wait for event links to appear on the page before extraction
7. **Scroll Loop** – Scroll the page three times to trigger additional event listings
8. **Link Extraction** – Collect all unique event links, titles, dates, and locations
9. **Stable ID Generation** – Hash each event URL into a consistent numeric ID
10. **Retry Handling** – Retry the full scrape attempt up to 3 times with backoff on failure
11. **Dataset Push** – Push each keyword's event list and summary status to the Dataset
12. **Rate Limiting** – Apply a randomized delay between keyword searches

**Key Benefits:**

- Pull **Meetup Event** data for any keyword without manually browsing the site
- Discover local and virtual community events across multiple topics in one run
- Track recurring or upcoming events for a specific interest area
- Feed local event dashboards, community research pipelines, or market research tools
- Automate recurring **Meetup Event** checks as new events are posted

***

### 📥 Input

The Actor accepts the following input parameters:

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `keywords` | string | `"startup"` | Comma-separated list of keywords to search for matching **Meetup Event** listings. |
| `max_events` | integer | `10` | Maximum number of events to collect per keyword. |
| `useApifyProxy` | boolean | `true` | Enable Apify proxy for the browser session. |
| `apifyProxyGroups` | array | `["RESIDENTIAL"]` | Proxy group configuration. |

**Example Input:**

```json
{
  "keywords": "startup, tech networking, book club",
  "max_events": 10,
  "useApifyProxy": true,
  "apifyProxyGroups": ["RESIDENTIAL"]
}
```

**Search a Single Keyword:**

```json
{
  "keywords": "yoga"
}
```

**Pull More Events per Keyword:**

```json
{
  "keywords": "hiking",
  "max_events": 30
}
```

***

### 📤 Output

The Actor pushes one **Meetup Event** result record per keyword, with the following structure:

| Field | Type | Description |
|-------|------|-------------|
| `meetup_events` | array | List of extracted event objects for this keyword (see below) |
| `total_events` | integer | Number of events found for this keyword |
| `keyword` | string | The search keyword this result set belongs to |
| `last_updated` | string | ISO 8601 timestamp of when the keyword's scrape completed |
| `status` | string | `"success"` if events were found, `"no_results"` otherwise |

Each object inside `meetup_events` contains:

| Field | Type | Description |
|-------|------|-------------|
| `event_id` | integer | Stable numeric ID generated by hashing the event URL |
| `event_name` | string | The event's title/name |
| `event_url` | string | Relative or absolute link to the event page |
| `event_date` | string | Date/time text found near the event listing, if visible |
| `location` | string | Venue/location text found near the event listing, if visible |
| `keyword` | string | The search keyword that surfaced this event |
| `created_at` | string | ISO 8601 timestamp of when the event was scraped |

**Example Meetup Event Output Record:**

```json
{
  "meetup_events": [
    {
      "event_id": 384729104857,
      "event_name": "Founders & Coffee: Monthly Startup Meetup",
      "event_url": "/startup-founders-hub/events/123456789/",
      "event_date": "Tue, Sep 9 · 6:00 PM EDT",
      "location": "WeWork Downtown, 123 Main St",
      "keyword": "startup",
      "created_at": "2026-08-29T09:00:00.000Z"
    }
  ],
  "total_events": 1,
  "keyword": "startup",
  "last_updated": "2026-08-29T09:00:05.000Z",
  "status": "success"
}
```

***

### 🧰 Technical Stack

- **Browser Automation:** \`\` (Chromium) for real, rendered access to Meetup's search pages
- **Hashing:** `hashlib` (MD5) for generating stable numeric event IDs from URLs
- **Pattern Matching:** `re` for parsing proxy URL credentials
- **Randomization:** `random` for user-agent rotation and request pacing
- **Async:** `asyncio` for non-blocking browser interaction and scrolling
- **Proxy:** Apify Proxy with `RESIDENTIAL` configuration, wired into 's launch options
- **Logging:** Apify Actor logging system
- **Platform:** Apify Actor serverless environment

***

### 📊 Data Fields Explained

#### **Event Identity**

- **event\_id**: A stable numeric identifier derived from hashing the event's URL
- **event\_name**: The event's title as shown in the search results
- **event\_url**: The link to the event's full Meetup page

#### **Event Details**

- **event\_date**: Date/time text extracted from near the event listing, when visible
- **location**: Venue or location text extracted from near the event listing, when visible

#### **Search Context**

- **keyword**: The search term that surfaced this event
- **created\_at / last\_updated**: Timestamps marking when the data was collected

***

### 🎯 Use Cases

- **Local Event Discovery** – Find upcoming community events for a specific interest or hobby
- **Community Research** – Track how active a topic's Meetup community is across cities
- **Market Research** – Gauge interest and event frequency around a niche or industry
- **Networking Prep** – Build a list of relevant events to attend for professional networking
- **Content Calendar Building** – Source real event dates and topics for local content planning
- **Academic Research** – Study public community event patterns at scale

***

### 🚀 Quick Start

#### **1. Prepare Input**

Go to Apify Console and enter:

```json
{
  "keywords": "startup"
}
```

#### **2. Run the Actor**

Click **Start**. The Actor will:

- Launch a headless browser and load Meetup's search results for each keyword
- Scroll to load additional events and extract event links
- Pull date and location text where available
- Push each keyword's event list to the Dataset

#### **3. Monitor Progress**

Console shows:

```
Scraping keyword: 'startup'
  Attempt 1/3 — keyword: 'startup'
  Loading: https://www.meetup.com/find/?keywords=startup&source=EVENTS
  Found 24 raw event links.
  Extracted 10 events.
  Pushed 10 events for 'startup'.
Done! Total events collected: 10
```

#### **4. View & Download Results**

- **Results Tab**: All **Meetup Event** result records
- **Export**: JSON, CSV, Excel, or HTML
- **Filter**: By keyword or status
- **API Access**: Available via the Apify API

***

### ⚙️ Configuration

Single keyword search:

```json
{
  "keywords": "yoga"
}
```

Multiple keywords in one run:

```json
{
  "keywords": "startup, tech networking, book club",
  "max_events": 15
}
```

Run without proxy:

```json
{
  "keywords": "startup",
  "useApifyProxy": false
}
```

***

### 📈 Performance

#### **Processing Speed**

- One browser session per keyword, with up to 3 scroll cycles and up to 3 retry attempts on failure
- \~2 second pause per scroll cycle, plus a randomized 2–4 second delay between keywords
- Slower than direct API access since a full browser session is launched per keyword

#### **Resource Usage**

- Memory: Moderate, since a Chromium browser instance is launched per keyword
- Network: Multiple page loads and scroll-triggered requests per keyword
- Proxy: One residential proxy tunnel shared across each keyword's browser session

***

### ⚠️ Important Notes

#### **Legal & Compliance**

- **Fair Use**: Applies pacing delays between keyword searches and scroll actions
- **Public Data Only**: Retrieves only publicly visible **Meetup Event** data exposed on the search results page
- **Legal**: Not legal advice — consult qualified professionals before using this data for compliance-sensitive decisions

#### **Data Quality**

- **Freshness**: Reflects Meetup's live search results at time of run
- **Completeness**: `event_date` and `location` depend on whether that text is visible near the event link at scrape time; either may return an empty string
- **Accuracy**: Sourced directly from Meetup's own rendered search results
- **Verification**: Cross-check high-stakes event details (dates, locations) against the live Meetup event page before relying on them

#### **Best Practices**

- Always configure a residential proxy for the most reliable **Meetup Event** access
- Use specific, niche keywords to surface more relevant local events
- Re-run periodically to catch newly posted events
- Expect `event_date` or `location` to occasionally be empty if that detail isn't visible in the search listing
- Increase `max_events` for broader coverage of high-activity keywords

***

### 📄 License & Legal

**Terms of Use:**

- Use for legitimate research, community discovery, and event planning purposes
- Respect Meetup's Terms of Service
- Use **Meetup Event** data responsibly and in compliance with applicable laws

**Disclaimer:**
Meetup Event Scraper is provided as-is for research and discovery purposes. Users are responsible for compliance with Meetup's ToS and all applicable laws. This is not legal advice.

***

### ⚖️ Meetup Event Excellence

This Actor is optimized for **Meetup Event** research with:

- ✅ Real, browser-rendered access with multi-strategy page loading
- ✅ Automation-detection evasion for more reliable access
- ✅ Scroll-triggered content loading for deeper coverage
- ✅ Retry-resilient scraping with automatic backoff
- ✅ Real-time Dataset push
- ✅ Production-ready code

# Actor input Schema

## `keywords` (type: `string`):

Comma-separated search keywords. Example: startup,tech,ai

## `max_events` (type: `integer`):

Maximum number of events to collect per keyword (default: 10).

## `useApifyProxy` (type: `boolean`):

Recommended to avoid Meetup bot detection.

## `apifyProxyGroups` (type: `array`):

RESIDENTIAL works best for Meetup.

## Actor input object example

```json
{
  "keywords": "startup,tech,ai",
  "max_events": 10,
  "useApifyProxy": true,
  "apifyProxyGroups": [
    "RESIDENTIAL"
  ]
}
```

# 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 = {
    "keywords": "startup,tech,ai"
};

// Run the Actor and wait for it to finish
const run = await client.actor("datapilot/meetup-event-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 = { "keywords": "startup,tech,ai" }

# Run the Actor and wait for it to finish
run = client.actor("datapilot/meetup-event-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 '{
  "keywords": "startup,tech,ai"
}' |
apify call datapilot/meetup-event-scraper --silent --output-dataset

```

## MCP server setup

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