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

Extract public Meetup event search results and event details by URL, keyword, or location.

- **URL**: https://apify.com/fetch\_cat/meetup-events-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Lead generation, Social media, Marketing
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 result 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/platform/actors/running/actors-in-store#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 Events Scraper

Extract public Meetup event data from Meetup search pages, group pages, event URLs, keywords, and locations. The Actor returns event records for event discovery, market research, community monitoring, and local event lead generation.

### What you can scrape

- Meetup keyword searches for public events
- Meetup location searches for public events
- Public Meetup group pages
- Public Meetup event detail pages
- Upcoming community events visible on public Meetup pages
- Event pages with organizer, group, venue, date, and attendance signals when available

### Who is it for

Meetup Events Scraper is useful for teams that need structured public event data without manually checking Meetup pages.

Common users include:

- Event marketers building lead lists
- Community managers tracking local meetups
- Recruiters monitoring technology and professional events
- Analysts measuring event density by topic or city
- Agencies creating city calendars or campaign lists
- Sales teams looking for relevant public gatherings

### Input recipes

Search for data events near Berlin:

```json
{
  "keywords": ["data"],
  "location": "Berlin, Germany",
  "maxItems": 10,
  "includeDetails": true,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

Scrape from a Meetup URL:

```json
{
  "startUrls": [{ "url": "https://www.meetup.com/find/?keywords=data&source=EVENTS" }],
  "maxItems": 10,
  "includeDetails": true
}
```

Collect a small sample first:

```json
{
  "keywords": ["startup"],
  "location": "New York, NY",
  "maxItems": 5,
  "includeDetails": false
}
```

### Input fields

- `startUrls` - public Meetup find, group, or event URLs.
- `keywords` - terms used to build Meetup event searches.
- `location` - optional Meetup search location, such as `Berlin, Germany`.
- `maxItems` - maximum number of event records to save.
- `includeDetails` - opens event detail pages for richer public fields.
- `resumeStartUrls` - URLs preserved from a previous checkpoint.
- `proxyConfiguration` - optional Apify Proxy settings.

### Output data

Each dataset item represents one public Meetup event and includes public event fields when available.

Typical fields include:

- `eventId`
- `eventUrl`
- `title`
- `description`
- `startDate`
- `endDate`
- `timezone`
- `isOnline`
- `venueName`
- `address`
- `city`
- `country`
- `groupName`
- `groupUrl`
- `organizerName`
- `imageUrl`
- `attendanceCount`
- `rsvpCount`
- `scrapedAt`

### Example inputs

Use the keyword recipe to monitor event topics in a city, or pass a public Meetup group URL to collect upcoming events for one community. Start with a small `maxItems` value, inspect the dataset, then increase the limit for larger exports.

### API usage

You can run the Actor from the Apify API, Apify client libraries, or Apify Console. Send the same JSON input shown above and read results from the default dataset after the run succeeds.

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/meetup-events-scraper').call({
  keywords: ['data'],
  location: 'Berlin, Germany',
  maxItems: 10,
  includeDetails: true,
});

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

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/meetup-events-scraper').call(run_input={
    'keywords': ['data'],
    'location': 'Berlin, Germany',
    'maxItems': 10,
    'includeDetails': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~meetup-events-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["data"],"location":"Berlin, Germany","maxItems":10,"includeDetails":true}'
```

### MCP

Use this Actor through Apify integrations or MCP-compatible workflows when you want an agent to collect public Meetup event data and pass the dataset into downstream analysis, enrichment, or notification steps.

Add the Apify MCP server to Claude Desktop or another compatible client, for example:

```bash
claude mcp add apify -- npx -y @apify/actors-mcp-server --actors fetch_cat/meetup-events-scraper
```

Example MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--actors", "fetch_cat/meetup-events-scraper"],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Example prompts:

- "Find public Meetup events about data in Berlin and return the titles, URLs, and dates."
- "Collect startup Meetup events in New York and summarize the groups organizing them."
- "Run the Meetup Events Scraper for this public Meetup URL and save the dataset for my next step."

### Pricing and limits

The Actor uses pay-per-event pricing with a small start charge and a per-result charge. Set `maxItems` to control run size and cost. For current rates, open the live Apify Pricing tab: https://apify.com/fetch\_cat/meetup-events-scraper/pricing

### Data freshness

Results reflect public Meetup pages at run time. Event details can change when organizers update their Meetup event pages.

### Proxy guidance

Direct connections often work for small public searches. If Meetup blocks a direct connection, enable Apify Proxy in the input.

### Deduplication

When multiple inputs point to the same public event, the Actor keeps one dataset item for that event URL. This helps combine keyword, location, and URL inputs without creating duplicate rows.

### Run strategy

For new searches, start with `maxItems` between 5 and 20. After confirming that the query returns the event type you need, increase `maxItems` for production exports.

### FAQ

#### Why did I get fewer events than `maxItems`?

Meetup may show fewer public events for the selected keyword, location, or group than your requested limit.

#### Can I scrape private Meetup content?

No. This Actor is intended for publicly available Meetup event information only.

#### Should I enable detail pages?

Use `includeDetails: true` when you need richer event fields. Use `includeDetails: false` for faster sampling from search results.

### Support

If a run does not return expected public events, include the input and run URL when opening an Apify issue so the problem can be reproduced.

### Related actors

Use this Actor with other event, venue, or local-business scrapers when building market maps, community calendars, or lead lists.

# Actor input Schema

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

Public Meetup find, group, or event URLs to scrape.

## `resumeStartUrls` (type: `array`):

Optional public Meetup URLs from a previous RUN\_CHECKPOINT. They are appended to Start URLs and preserve the original input fields.

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

Search keywords used to build public Meetup event search URLs.

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

Optional Meetup search location, such as 'Berlin, Germany' or 'New York, NY'.

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

Maximum number of Meetup events to save.

## `includeDetails` (type: `boolean`):

Fetch event detail pages to enrich search results with the most complete public fields.

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

Optional Apify Proxy settings. Datacenter proxies are usually sufficient; use residential only if your run is blocked.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.meetup.com/find/?keywords=data&source=EVENTS"
    }
  ],
  "keywords": [
    "data"
  ],
  "location": "Berlin, Germany",
  "maxItems": 10,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.meetup.com/find/?keywords=data&source=EVENTS"
        }
    ],
    "keywords": [
        "data"
    ],
    "location": "Berlin, Germany",
    "maxItems": 10,
    "includeDetails": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/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 = {
    "startUrls": [{ "url": "https://www.meetup.com/find/?keywords=data&source=EVENTS" }],
    "keywords": ["data"],
    "location": "Berlin, Germany",
    "maxItems": 10,
    "includeDetails": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/meetup-events-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.meetup.com/find/?keywords=data&source=EVENTS"
    }
  ],
  "keywords": [
    "data"
  ],
  "location": "Berlin, Germany",
  "maxItems": 10,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetch_cat/meetup-events-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetch_cat/meetup-events-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/fzEeOLykfcmre15oy/builds/eyeFqucK5ze3wgWd5/openapi.json