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

Meetup Events API. Search and extract 20+ data fields from Meetup.com events by keyword, location, category, date range & format. No login or API key needed.

- **URL**: https://apify.com/epicscrapers/meetup-events-scraper.md
- **Developed by:** [Epic Scrapers](https://apify.com/epicscrapers) (community)
- **Categories:** Social media, Lead generation, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 events

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 ⭐

![Meetup Events Scraper — Extract event data from Meetup.com](https://raw.githubusercontent.com/jwlben11/hosted-images/main/banner.svg)

**[Search and extract detailed event data from [Meetup.com](https://www.meetup.com) — the world's largest platform for local community events — by keyword, location (city, zip, or lat/lon), category, date range, radius, and event format. No login, no API key, no browser required.]**

Search by **keyword**, **location**, **category**, **date range**, and **event format**. Returns **20+ structured fields** per event including title, date/time, description, venue with coordinates, group details, RSVP count, fee information, topic tags, and high-resolution photos. Up to **500 events** per run. No authentication, no API key, and no browser overhead — just clean, fast data.

### 📊 Comparison: Meetup Events Scraper ⭐ vs. Competitors

| Feature | Meetup Events Scraper ⭐ | ScrapePilot Meetup | Automation Lab Meetup | Filip Č. Meetup Scraper |
|---|---|---|---|---|
| **Search by keyword** | ✅ | ✅ | ✅ | ✅ |
| **Search by city name** | ✅ | ✅ | ✅ | ✅ |
| **Search by lat/lon coordinates** | ✅ | ❌ | ❌ | ❌ |
| **Search by zip code** | ✅ | ❌ | ❌ | ❌ |
| **Adjustable search radius (miles)** | ✅ | ❌ | ❌ | ❌ |
| **Category filter (20 categories)** | ✅ | ❌ | ❌ | ❌ |
| **Minimum RSVP filter** | ✅ | ❌ | ❌ | ❌ |
| **Event format filter (Physical/Online/Hybrid)** | ✅ | ❌ | ❌ | ❌ |
| **Custom date range picker** | ✅ | ❌ | ❌ | ❌ |
| **Events in the next N days** | ✅ | ✅ | ✅ | ✅ |
| **Venue name, address, city, state, lat/lon** | ✅ | Partial | ✅ | Partial |
| **Topic tags (with IDs)** | ✅ | ✅ | ❌ | ❌ |
| **Group name + urlname** | ✅ | ✅ | ✅ | ✅ |
| **RSVP / attendee count** | ✅ | ✅ | ✅ | ✅ |
| **Fee / pricing info** | ✅ | ❌ | ✅ | ✅ |
| **Event photo (high-res)** | ✅ | ❌ | ✅ | ❌ |
| **Online event detection** | ✅ | ✅ | ✅ | ✅ |
| **Duration (ISO 8601)** | ✅ | ❌ | ❌ | ❌ |
| **Event status (Active/Cancelled)** | ✅ | ❌ | ❌ | ❌ |
| **Search location metadata** | ✅ | ❌ | ❌ | ❌ |
| **No login required** | ✅ | ✅ | ✅ | ✅ |
| **No browser automation** | ✅ | ❌ | ❌ | ✅ |
| **Custom max results up to 500** | ✅ | ❌ | ❌ | ❌ |

### 🚀 Features

- **🔍 Keyword search** — Search for any type of event: `tech`, `yoga`, `startup`, `board games`, `photography`, `machine learning`, or anything else. Meetup's search engine surfaces relevant events across all groups.
- **📍 Flexible location input** — Enter a city name (`San Francisco`), a lat/lon pair (`37.78,-122.41`), or a zip code (`10001`). The scraper geocodes it automatically so you can search anywhere in the world.
- **📏 Adjustable search radius** — Control how far to look from your location point, from 1 to 500 miles. Default is 25 miles — perfect for a city-wide search.
- **📂 Category filtering** — Narrow results to one of 20 Meetup categories including Technology, Music, Sports & Fitness, Career & Business, Science & Education, Social Activities, and more. Works alongside your keyword to refine results.
- **📅 Flexible date filtering** — Search for events happening in the next N days, or set a custom date range with start/end date pickers. Perfect for planning a specific week or month.
- **🎟️ Event format filter** — Filter by `Physical` (in-person), `Online` (virtual), or `Hybrid` events. Useful for finding local in-person networking or global virtual conferences.
- **👥 Minimum RSVP threshold** — Set a minimum attendee count to only surface popular, high-engagement events. Example: minimum 10 RSVPs filters out low-turnout events.
- **🔢 Custom result limits** — Set max results from 1 to 500. Use small limits for quick tests, larger limits for comprehensive market research.
- **📊 Rich output (20+ fields)** — Every event returns title, date/time, duration, description, venue with GPS coordinates, group name and URL, RSVP count, fee info, topic tags, event status, high-res photos, and online event detection.
- **⚡ No browser, no login, no API key** — Uses Meetup's lightweight API directly. No heavy browser automation means faster runs and lower compute costs.
- **🌐 Automatic pagination** — The scraper automatically walks through all result pages to collect every matching event, up to your specified limit.

### 📋 What You Get

Every scraped event returns **22 fields** of structured data:

| Field | Type | Description | Example |
|---|---|---|---|
| `id` | string | Unique Meetup event identifier | `"315237783"` |
| `title` | string | Full event title | `"IGDA SF @ MADE - Developer Showcase with Speaker Series"` |
| `dateTime` | string | Event start date and time (ISO 8601) | `"2026-06-25T18:00:00-07:00"` |
| `endTime` | string | Event end date and time (ISO 8601) | `"2026-06-25T21:00:00-07:00"` |
| `duration` | string | Duration in ISO 8601 format | `"PT3H"` |
| `eventType` | string | Event format: `PHYSICAL`, `ONLINE`, or `HYBRID` | `"PHYSICAL"` |
| `status` | string | Event status: `ACTIVE`, `CANCELLED`, or `PAST` | `"ACTIVE"` |
| `isOnline` | boolean | Whether the event is held virtually | `false` |
| `description` | string | Event description (first 500 characters) | `"Join us for an evening of developer showcases..."` |
| `url` | string | Direct URL to the event page | `"https://www.meetup.com/igda-silicon-valley-san-francisco/events/315237783/"` |
| `imageUrl` | string | High-resolution event photo URL | `"https://secure.meetupstatic.com/photos/event/c/3/1/a/highres_534709946.jpeg"` |
| `displayImageUrl` | string | Alternative event photo URL | `"https://secure.meetupstatic.com/photos/event/c/3/1/a/highres_534709946.jpeg"` |
| `topics` | array | List of topic tags with name and ID | `[{"name": "Video Games", "id": "4471"}, {"name": "Indie Games", "id": "42010"}]` |
| `venue` | object | Venue name, address, city, state, lat, lon | `{"name": "MADE", "address": "921 Washington St", "city": "Oakland", "state": "CA", "lat": 37.80199, "lon": -122.27435}` |
| `group` | object | Group name and URL slug | `{"name": "IGDA Silicon Valley & San Francisco", "urlname": "igda-silicon-valley-san-francisco"}` |
| `fee` | object | Fee currency and amount (null if free) | `{"currency": "USD", "amount": 10.00}` |
| `rsvpCount` | integer | Number of confirmed attendees | `13` |
| `location` | object | Searched location metadata | `{"searched": "San Francisco, CA, USA", "lat": 37.78, "lon": -122.42}` |
| `query` | string | Search term used to find this event | `"tech"` |

### 🔗 Related Actors

| Actor | Description |
|---|---|
| [Google News Scraper](https://apify.com/epicscrapers/google-news-scraper) | Monitor news coverage of events, industries, and companies |
| [Webpage to Markdown](https://apify.com/epicscrapers/webpage-to-markdown) | Convert any event or landing page to clean Markdown for LLM ingestion |
| [YouTube Transcript Scraper AI](https://apify.com/epicscrapers/youtube-transcript-scraper) | Extract transcripts of event recordings and conference talks |

### 📥 Input

| Input | Type | Required | Default | Description |
|---|---|---|---|---|
| `location` | string | ✅ Yes | — | City name (e.g., `San Francisco`), lat/lon pair (`37.78,-122.41`), or zip code (`10001`) |
| `query` | string | ✅ Yes | — | Search term for events (e.g., `tech`, `AI`, `yoga`, `startup`) |
| `radius` | integer | ❌ No | `25` | Search radius in miles (1–500) |
| `days` | integer | ❌ No | — | Only fetch events in the next N days (overridden by custom date range) |
| `maxResults` | integer | ❌ No | `30` | Maximum events to return. Set `0` for unlimited (up to 500) |
| `eventType` | string | ❌ No | All formats | Filter by format: `PHYSICAL`, `ONLINE`, `HYBRID`, or empty for all |
| `topicCategoryId` | string | ❌ No | All categories | Filter by Meetup category ID (e.g., `"521"` for Art & Culture, `"701"` for Technology) |
| `minRsvpCount` | integer | ❌ No | — | Minimum number of RSVPs to include an event |
| `startDate` | string | ❌ No | — | Custom date range start (ISO format, overrides `days` when both `startDate` and `endDate` are set) |
| `endDate` | string | ❌ No | — | Custom date range end (ISO format, must be after `startDate`) |

#### Example Input

```json
{
  "location": "San Francisco, CA",
  "query": "tech",
  "radius": 25,
  "days": 30,
  "maxResults": 50,
  "eventType": "PHYSICAL",
  "topicCategoryId": "701",
  "minRsvpCount": 5
}
````

#### Example Output

```json
{
  "id": "315237783",
  "title": "IGDA SF @ MADE - Developer Showcase with Speaker Series",
  "dateTime": "2026-06-25T18:00:00-07:00",
  "endTime": "2026-06-25T21:00:00-07:00",
  "duration": "PT3H",
  "eventType": "PHYSICAL",
  "status": "ACTIVE",
  "isOnline": false,
  "description": "Join us for an evening of developer showcases, lightning talks, and networking with the game developer community in the Bay Area. MADE (Museum of Art and Digital Entertainment) hosts this monthly event featuring local indie developers presenting their latest projects.",
  "url": "https://www.meetup.com/igda-silicon-valley-san-francisco/events/315237783/",
  "imageUrl": "https://secure.meetupstatic.com/photos/event/c/3/1/a/highres_534709946.jpeg",
  "displayImageUrl": "https://secure.meetupstatic.com/photos/event/c/3/1/a/highres_534709946.jpeg",
  "topics": [
    { "name": "Video Game Entrepreneurs", "id": "32996" },
    { "name": "Independent Game Development", "id": "29057" },
    { "name": "Indie Games", "id": "42010" },
    { "name": "Professional Networking", "id": "17381" },
    { "name": "Video Games", "id": "4471" }
  ],
  "venue": {
    "name": "MADE",
    "address": "921 Washington St, Oakland, CA 94607",
    "city": "Oakland",
    "state": "CA",
    "lat": 37.80199,
    "lon": -122.27435
  },
  "group": {
    "name": "IGDA Silicon Valley & San Francisco",
    "urlname": "igda-silicon-valley-san-francisco"
  },
  "fee": null,
  "rsvpCount": 13,
  "location": {
    "searched": "San Francisco, CA, USA",
    "lat": 37.78,
    "lon": -122.42
  },
  "query": "tech"
}
```

### 💡 Use Cases

#### **Event Discovery for Job Seekers & Career Changers**

Job seekers and career changers can use this scraper to find industry-specific networking events, workshops, and meetups in any city. By searching for keywords like `software engineering`, `product management`, `UX design`, or `data science`, you can discover all upcoming professional events in your target field within a specified radius of your location.

The `venue` field provides the exact address and GPS coordinates, making it easy to plan your commute. The `rsvpCount` field helps you gauge which events are popular and worth attending — a meetup with 50+ RSVPs is likely a well-organized, high-value networking opportunity. The `group` field lets you research the host organization before attending.

Instead of manually checking 20 different Meetup groups every week, run this scraper once and get a consolidated calendar of every relevant professional event in your area. Filter by `PHYSICAL` events for in-person networking or `ONLINE` for remote learning opportunities.

#### **Market Research for Event Organizers & Community Managers**

Event organizers and community managers can use this scraper to conduct competitive intelligence on their local events landscape. Search for events in your category — for example, if you run a tech meetup, search for `tech` or `startup` in your city with a 10-mile radius.

The `rsvpCount` field reveals which events and groups are driving the highest engagement. The `topics` array shows what sub-themes are popular (e.g., `Artificial Intelligence`, `Blockchain`, `Web Development`), helping you identify trending topics to feature at your own events. The `group` field lets you identify potential collaborators or competitors.

By running this scraper weekly, you can monitor how the events landscape evolves — which groups are growing, which topics are gaining traction, and what formats (online vs. in-person) are most popular. Use this data to position your events competitively and fill gaps in the market.

#### **Lead Generation for B2B Sales Teams**

B2B sales teams targeting specific industries can use this scraper to generate event-based leads. Search for events by keyword relevant to your target market — for example, a company selling DevOps tools would search for `Kubernetes`, `Docker`, `CI/CD`, or `cloud infrastructure` in major tech hubs.

Each event returns the `group` name and URL, the `venue` details, and the `rsvpCount` — giving you rich context for outreach. A Docker meetup with 80 RSVPs in San Francisco represents a concentrated pool of your ICP (Ideal Customer Profile). Use the event `url` to register and attend, or use the `group` name to identify the organizers for partnership outreach.

This is far more efficient than cold calling. Every event represents a pre-qualified audience of people actively interested in your domain. Run scheduled scrapes across 5-10 cities to build a pipeline of events and groups to engage with.

#### **Content Marketing & Editorial Planning**

Content marketers and editors can use this scraper to identify trending topics and community interests within their industry. By tracking event titles, descriptions, and topics over time, you can spot emerging themes before they become mainstream.

For example, a technology publication could run weekly scrapes for `AI`, `machine learning`, `blockchain`, and `cybersecurity` across major cities. The `topics` array reveals the sub-niches gaining traction. If you see a surge in events tagged with `AI Ethics` or `Responsible AI`, that's a signal to produce content on those themes.

The `group` names and descriptions also help identify thought leaders and organizations driving conversations in your space. Reach out to event organizers for quotes, guest posts, or collaboration opportunities. This scraper turns Meetup's live event data into a real-time content strategy tool.

#### **Academic & Social Research**

Researchers studying urban sociology, community formation, or technology adoption patterns can use this scraper to collect structured event data at scale. The ability to search by location, category, and date range makes it possible to run longitudinal studies across multiple cities.

The `topics` field provides granular category data that can be analyzed for trend detection — for example, tracking how AI-related events have grown as a percentage of all tech events over time. The `rsvpCount` field offers a proxy for community engagement levels. The `venue` coordinates enable geospatial analysis of where community events cluster in a city.

With up to 500 events per run and filters for date ranges, researchers can build comprehensive datasets spanning months or years. Export the data as JSON or CSV for analysis in Python, R, or SPSS.

#### **Travel & Event Planning for Digital Nomads**

Digital nomads and remote workers can use this scraper to plan trips around events that match their interests. Before visiting a new city, search for events by keyword (`digital nomad`, `coworking`, `blockchain`, `yoga`) and see what's happening during your stay.

The `startDate`/`endDate` filters let you target specific travel dates. The `venue` field with GPS coordinates helps you find events near your accommodation. The `PHYSICAL` filter ensures you find in-person community events rather than just online gatherings.

This transforms the travel planning experience — instead of hoping to stumble upon local events, you arrive with a curated calendar of relevant meetups, workshops, and social gatherings already in hand. Use the `group` field to research each community's vibe before committing your evening.

### ❓ Frequently Asked Questions

**How do I search for events?**
Enter a **location** (city name like `London`, lat/lon like `51.50,-0.12`, or zip code like `10001`) and a **search term** (like `tech`, `yoga`, `photography`, or `startup`). The scraper will find matching events near that location. For example, searching `"Berlin"` + `"AI"` returns all AI-themed events in Berlin. You can also add optional filters like category, distance radius, and date range to narrow results.

**How many events can I scrape in a single run?**
You can set `maxResults` up to **500 events** per run. Set it to `0` for unlimited results (capped at 500 by the scraper for practical reasons). For quick tests, use a smaller limit like 10–30. The default is 30 events — a good balance between comprehensiveness and speed.

**Do I need a Meetup account or login?**
No. This scraper only accesses **publicly available event data** from Meetup.com. No account, login, cookies, or API keys are required. You can start scraping immediately with just the Apify platform.

**What locations are supported?**
Any location worldwide. You can input a **city name** (`Tokyo`, `São Paulo`, `Cape Town`), a **latitude/longitude pair** (`35.68,139.76`), or a **zip/postal code** (`90210`, `EC2A 4NE`). The scraper geocodes all inputs automatically using Meetup's location search, so you're never limited to a predefined list of cities.

**How fresh is the event data?**
The data is **live and real-time**. Every run queries Meetup directly, so you always get the current state of events — including newly posted events, updated RSVP counts, and any cancellations or reschedules. The `dateTime` and `status` fields reflect the latest data from Meetup.

**Can I get past events or only upcoming ones?**
The scraper is designed for **upcoming events**. It searches forward from the current date. You can use the `startDate` and `endDate` parameters to target a specific historical window, but Meetup's search primarily surfaces current and future events. For past events, consider running the scraper before the event date to capture it.

**Can I filter by event category (e.g., Technology, Music, Sports)?**
Yes. The `topicCategoryId` input lets you filter by **20 predefined Meetup categories** including Technology (`701`), Career & Business (`405`), Music (`395`), Sports & Fitness (`482`), Social Activities (`652`), and more. Combine a category with your keyword for precise results — for example, search `"AI"` within the Technology category to skip non-tech AI events.

**What export formats are supported?**
All Apify dataset export formats are supported: **JSON, CSV, Excel, HTML table, XML, and RSS**. You can download results directly from the Apify Console or access them programmatically via the Apify API. The data integrates with Google Sheets, Airtable, and thousands of other tools through Apify integrations (Zapier, Make, webhooks).

**Is this better than using the Meetup API directly?**
Meetup's official API requires a **paid Pro subscription** to access, and even then it's limited in scope and rate-limited. This scraper accesses the same structured data through Meetup's public GraphQL interface — no subscription, no rate limit worries, and no API key management. Plus you get advanced features like search radius, category filtering, and minimum RSVP thresholds that the official API doesn't expose.

**What are alternatives to Meetup events search?**
If you need event data beyond Meetup, consider Eventbrite, Lu.ma, or aggregator platforms. However, Meetup remains the **largest platform for local community events** with the broadest geographic coverage. Our related Eventbrite Scraper can complement this actor for comprehensive multi-platform event coverage. For user-generated content about events, pair this with our Google News Scraper for media coverage and our YouTube Transcript Scraper for event recordings.

### SEO Keywords

meetup events scraper, meetup.com scraper, scrape meetup events, meetup data extraction, meetup event data, meetup search scraper, meetup event API alternative, tech events scraper, networking events data, community events database, local events scraper, event lead generation, meetup RSVP scraper, event data for market research, meetup group scraper, find tech meetups, event aggregation tool, meetup events to CSV, online events scraper, in-person events data, hybrid events scraper, meetup location scraper, meetup category scraper, event discovery tool, Apify meetup actor, scrape meetup without API, event intelligence tool, community management data, professional networking events, startup events data, meetup scraping no login

### ⚠️ Disclaimer

This Actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Meetup.com, WeWork Companies Inc., or any of their subsidiaries**. All trademarks are the property of their respective owners.

This Actor accesses only publicly available event data on `meetup.com`. You are solely responsible for ensuring your use complies with the site's Terms of Service and applicable laws.

# Actor input Schema

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

Enter a city name like <b>San Francisco</b>, a lat,lon pair like <b>40.71,-74.0</b>, or a zip code like <b>10001</b>.

## `query` (type: `string`):

What kind of events are you looking for? Try <b>tech</b>, <b>AI</b>, <b>startup</b>, <b>yoga</b>, <b>board games</b>, or anything else.

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

How far from the location to search, in miles. Default is <b>25</b>.

## `days` (type: `integer`):

Only fetch events happening in the next N days. Leave empty for no limit.

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

How many events to return. Set to <b>30</b> (default) for a good sample, or <b>0</b> to get all matching events. Useful for quick tests or to limit costs.

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

Filter by how the event is held.

## `topicCategoryId` (type: `string`):

Only show events in a specific Meetup category. Leave as <b>All categories</b> for everything. Categories like Technology, Sports & Fitness, Music, etc. work alongside your search term to narrow results.

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

Only include events with at least this many people going. For example, set this to <b>10</b> to only see events with 10+ confirmed attendees. Leave empty for no minimum.

## `startDate` (type: `string`):

Start of a custom date range. Overrides <b>Days Ahead</b> if both <b>Start</b> and <b>End</b> are set. Useful for a specific week or month instead of starting from today.

## `endDate` (type: `string`):

End of a custom date range. Must be after the start date. Overrides <b>Days Ahead</b> if both <b>Start</b> and <b>End</b> are set.

## Actor input object example

```json
{
  "location": "San Francisco",
  "query": "tech",
  "radius": 25,
  "days": 7,
  "maxResults": 30,
  "eventType": "",
  "topicCategoryId": ""
}
```

# Actor output Schema

## `results` (type: `string`):

Scraped data records in JSON format

# 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 = {
    "location": "San Francisco",
    "query": "tech",
    "days": 7,
    "startDate": "",
    "endDate": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("epicscrapers/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 = {
    "location": "San Francisco",
    "query": "tech",
    "days": 7,
    "startDate": "",
    "endDate": "",
}

# Run the Actor and wait for it to finish
run = client.actor("epicscrapers/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 '{
  "location": "San Francisco",
  "query": "tech",
  "days": 7,
  "startDate": "",
  "endDate": ""
}' |
apify call epicscrapers/meetup-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Meetup Events Scraper",
        "description": "Meetup Events API. Search and extract 20+ data fields from Meetup.com events by keyword, location, category, date range & format. No login or API key needed.",
        "version": "0.0",
        "x-build-id": "lg3V8E6DqOyI7FF3e"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/epicscrapers~meetup-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-epicscrapers-meetup-events-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/epicscrapers~meetup-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-epicscrapers-meetup-events-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/epicscrapers~meetup-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-epicscrapers-meetup-events-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "location",
                    "query"
                ],
                "properties": {
                    "location": {
                        "title": "📍 Location",
                        "type": "string",
                        "description": "Enter a city name like <b>San Francisco</b>, a lat,lon pair like <b>40.71,-74.0</b>, or a zip code like <b>10001</b>."
                    },
                    "query": {
                        "title": "🔎 Search Term",
                        "type": "string",
                        "description": "What kind of events are you looking for? Try <b>tech</b>, <b>AI</b>, <b>startup</b>, <b>yoga</b>, <b>board games</b>, or anything else."
                    },
                    "radius": {
                        "title": "📏 Search Radius",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How far from the location to search, in miles. Default is <b>25</b>.",
                        "default": 25
                    },
                    "days": {
                        "title": "📅 Days Ahead",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Only fetch events happening in the next N days. Leave empty for no limit."
                    },
                    "maxResults": {
                        "title": "🔢 Max results",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many events to return. Set to <b>30</b> (default) for a good sample, or <b>0</b> to get all matching events. Useful for quick tests or to limit costs.",
                        "default": 30
                    },
                    "eventType": {
                        "title": "🎟️ Event Format",
                        "enum": [
                            "",
                            "PHYSICAL",
                            "ONLINE",
                            "HYBRID"
                        ],
                        "type": "string",
                        "description": "Filter by how the event is held.",
                        "default": ""
                    },
                    "topicCategoryId": {
                        "title": "📂 Category",
                        "enum": [
                            "",
                            "521",
                            "405",
                            "604",
                            "612",
                            "535",
                            "511",
                            "571",
                            "622",
                            "642",
                            "395",
                            "673",
                            "701",
                            "593",
                            "436",
                            "652",
                            "482",
                            "449",
                            "546",
                            "684",
                            "467"
                        ],
                        "type": "string",
                        "description": "Only show events in a specific Meetup category. Leave as <b>All categories</b> for everything. Categories like Technology, Sports & Fitness, Music, etc. work alongside your search term to narrow results.",
                        "default": ""
                    },
                    "minRsvpCount": {
                        "title": "👥 Minimum RSVPs",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include events with at least this many people going. For example, set this to <b>10</b> to only see events with 10+ confirmed attendees. Leave empty for no minimum."
                    },
                    "startDate": {
                        "title": "📆 Custom Date Range (Start)",
                        "type": "string",
                        "description": "Start of a custom date range. Overrides <b>Days Ahead</b> if both <b>Start</b> and <b>End</b> are set. Useful for a specific week or month instead of starting from today."
                    },
                    "endDate": {
                        "title": "📆 Custom Date Range (End)",
                        "type": "string",
                        "description": "End of a custom date range. Must be after the start date. Overrides <b>Days Ahead</b> if both <b>Start</b> and <b>End</b> are set."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
