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

Scrape public Meetup.com events by keyword + location, group URL, or event URL. RSVP counts, venue, price, organizer group. HTTP-only, no login, MCP-ready.

- **URL**: https://apify.com/khadinakbar/meetup-events-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, Social media, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 event scrapeds

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/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

Scrape public **Meetup.com events** at scale — by keyword + location, by group, or by a single event URL. Get the data Meetup's UI hides behind infinite scroll: RSVP counts, venue with coordinates, free/paid + price, online/in-person/hybrid format, and the full organizer group (name, member count, founder). HTTP-only via Meetup's own backend — no login, no cookies, fast and reliable. **MCP-ready** for AI agents.

### What it does

Give it keywords + a location, a Meetup group URL, or an event URL — the actor auto-detects the mode and returns one clean, flat record per event.

| Mode | Input you provide | What you get |
|------|-------------------|--------------|
| **Keyword + location search** | `searchQueries` + `city`/`zip`/`lat`+`lon` | Every matching public event, deep-paginated past the website's scroll cap |
| **Group events** | `groupUrls` (URL or urlname) | A group's full upcoming or past event list |
| **Single event** | `eventUrls` (URL or numeric ID) | Full detail for specific events you already know |

You can combine modes in one run — results are deduplicated by event ID.

### When to use it

- **Event marketers & community managers** — find local tech, business, or hobby meetups to sponsor, partner with, or attend.
- **Lead generation** — surface active organizer groups (with member counts) in a city and niche.
- **Market & trend research** — measure event volume, RSVP demand, and topics by location over time.
- **AI agents** — a clean tool call: query in, structured JSON events out.

### Output

One record per event. Key fields:

| Field | Description |
|-------|-------------|
| `title` | Event name |
| `eventUrl` | Canonical Meetup event URL |
| `dateTime` / `endTime` | Start / end (ISO 8601 with timezone offset) |
| `eventType` | `PHYSICAL`, `ONLINE`, or `HYBRID` |
| `goingCount` | Number of people who RSVP'd "going" |
| `isPaid` / `price` / `currency` | Ticketing — free vs paid, and the amount |
| `description` | Full event description (markdown) |
| `topics` | Array of event/group topic tags |
| `venueName` … `venueLat` / `venueLon` | Venue name, address, city, state, country, postal code, coordinates |
| `groupName` / `groupUrlname` / `groupUrl` | Organizer group identity |
| `groupMemberCount` | Group size — useful for lead scoring |
| `groupOrganizer` | Organizer display name |
| `groupFoundedDate` / `groupTimezone` | Group metadata |
| `photoUrl` | High-res event/group photo |
| `maxTickets` / `rsvpState` / `status` | Capacity + RSVP state |

#### Example record

```json
{
  "id": "315288903",
  "title": "Astoria Tech Meetup #55",
  "eventUrl": "https://www.meetup.com/astoria-tech-meetup/events/315288903/",
  "dateTime": "2026-06-30T18:30:00-04:00",
  "eventType": "PHYSICAL",
  "goingCount": 58,
  "isPaid": false,
  "topics": ["Software Development", "Web Technology"],
  "venueName": "Our House Queens",
  "venueCity": "Queens County",
  "venueLat": 40.77273,
  "venueLon": -73.91446,
  "groupName": "Astoria Tech Meetup",
  "groupMemberCount": 3006,
  "groupOrganizer": "Peter Valdez"
}
```

### Pricing

**Pay-per-event:** **$0.004 per unique event** returned, plus a $0.00005 run-start fee. Events are deduplicated across modes, and you are never charged past your `maxItems` cap — so cost is predictable. A 200-event run costs ~$0.80.

### Input examples

#### Search a city for a topic

```json
{
  "searchQueries": ["technology", "ai"],
  "city": "New York",
  "lat": 40.7128,
  "lon": -74.006,
  "radius": 50,
  "maxItems": 200
}
```

#### Pull every upcoming event from a group

```json
{
  "groupUrls": ["https://www.meetup.com/a11ynyc/"],
  "groupEventStatus": "upcoming"
}
```

#### Enrich a known list of events

```json
{
  "eventUrls": [
    "https://www.meetup.com/astoria-tech-meetup/events/315288903/",
    "315426561"
  ]
}
```

### Run it from code

#### Apify JavaScript client

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('khadinakbar/meetup-events-scraper').call({
    searchQueries: ['startup networking'],
    city: 'New York',
    lat: 40.7128,
    lon: -74.006,
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Apify Python client

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("khadinakbar/meetup-events-scraper").call(run_input={
    "groupUrls": ["https://www.meetup.com/a11ynyc/"],
    "groupEventStatus": "upcoming",
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["dateTime"], item["goingCount"])
```

### Use with AI agents (MCP)

This actor is MCP-ready. Expose it through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) and an agent can call it directly:

> "Find AI meetups in San Francisco next month with at least 20 RSVPs."

Narrow input, flat structured output, predictable per-event cost — designed for tool selection.

### Tips

- **Search is location-scoped.** Always pair `searchQueries` with a `city`, `zip`, or `lat`+`lon`. Without a location, Meetup returns nothing.
- **`lat`+`lon`+`radius`** gives the most precise geographic targeting; `city` is the easy option.
- Use **`minRsvpCount`** to skip tiny events, and **`eventType`** to keep only in-person or only online.
- The default **datacenter proxy** is fast and cheap for this cookieless API. Switch `proxyConfiguration` to RESIDENTIAL only if you ever see blocks.

### FAQ

**Do I need a Meetup login or cookies?** No. The actor uses Meetup's public backend and requires no authentication.

**How many events can it return?** As many as match, up to your `maxItems` cap. Search paginates with cursors well past the website's visible scroll limit.

**Can I get past events?** Yes — set `groupEventStatus: "past"` in group mode.

**Does it return attendee personal data?** No. It returns aggregate RSVP counts (`goingCount`), not attendee identities or contact details.

### Legal

This actor scrapes only **publicly available** event information from Meetup.com — the same data any visitor can see without logging in. It does not access private groups, attendee personal data, or any login-gated content. Use the data in compliance with Meetup's Terms of Service and applicable laws (including GDPR/CCPA where relevant). You are responsible for how you use scraped data. This tool is provided for legitimate research, marketing, and lead-generation purposes.

# Actor input Schema

## `searchQueries` (type: `array`):

Keyword searches run on Meetup events, one entry per term (e.g. 'technology', 'yoga', 'startup networking'). Pair with a location (city, zip, or lat+lon) — Meetup search is location-scoped. Leave empty if you only want group or event URLs. NOT a group or event URL.

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

City to scope the keyword search to (e.g. 'New York'). Combine with state/country for accuracy. Ignored for group-URL and event-URL modes. NOT a venue name.

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

State or region code for the search location (e.g. 'NY'). Optional refinement on top of city. Ignored outside search mode. NOT a country.

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

Two-letter country code for the search location (e.g. 'us', 'gb'). Optional. Ignored outside search mode.

## `zip` (type: `string`):

Postal code to scope the search (e.g. '10001'). Alternative to city. Ignored outside search mode.

## `lat` (type: `number`):

Latitude for a precise geo-scoped search (e.g. 40.7128). Use with lon and radius for map-bounded searches. Optional. Ignored outside search mode.

## `lon` (type: `number`):

Longitude for a precise geo-scoped search (e.g. -74.006). Use with lat and radius. Optional. Ignored outside search mode.

## `radius` (type: `number`):

Search radius in miles around the lat/lon or city (e.g. 50). Defaults to Meetup's default when omitted. Ignored outside search mode.

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

Restrict search results to a single format. PHYSICAL = in-person, ONLINE = virtual, HYBRID = both. Leave as 'Any' for all formats. Ignored outside search mode.

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

Only return search events starting on or after this ISO 8601 datetime (e.g. '2026-07-01T00:00:00Z'). Optional. Ignored outside search mode.

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

Only return search events starting on or before this ISO 8601 datetime (e.g. '2026-08-01T00:00:00Z'). Optional. Ignored outside search mode.

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

Only return search events with at least this many RSVPs (e.g. 10) — filters out tiny events. Optional. Ignored outside search mode.

## `sortField` (type: `string`):

Order search results by RELEVANCE (Meetup's match score) or DATETIME (chronological). Defaults to RELEVANCE. Ignored outside search mode.

## `groupUrls` (type: `array`):

Meetup group URLs or urlnames to pull every event from (e.g. 'https://www.meetup.com/nyc-tech/' or just 'nyc-tech'). Returns the group's upcoming or past events (see groupEventStatus). NOT an event URL.

## `groupEventStatus` (type: `string`):

For group-URL mode, choose which events to return: upcoming (future, ascending) or past (history, most-recent first). Defaults to upcoming. Only applies to groupUrls.

## `eventUrls` (type: `array`):

Specific Meetup event URLs or numeric event IDs to fetch directly (e.g. 'https://www.meetup.com/nyc-tech/events/315015546/' or '315015546'). Best for enriching a known list of events. NOT a group URL.

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

Hard cap on total unique events returned across all modes (e.g. 200). Stops pagination and charging once reached. Defaults to 200. Raise for deep crawls.

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

Proxy used for Meetup's GraphQL backend. Apify datacenter (default) is fast and cheap for this cookieless API; switch to RESIDENTIAL only if you hit blocks.

## Actor input object example

```json
{
  "searchQueries": [
    "technology",
    "ai"
  ],
  "city": "New York",
  "eventType": "ANY",
  "sortField": "RELEVANCE",
  "groupUrls": [
    "https://www.meetup.com/a11ynyc/"
  ],
  "groupEventStatus": "upcoming",
  "eventUrls": [
    "https://www.meetup.com/a11ynyc/events/315015546/"
  ],
  "maxItems": 200,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `events` (type: `string`):

No description

## `eventsCsv` (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 = {
    "searchQueries": [
        "technology"
    ],
    "city": "New York",
    "maxItems": 200,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "searchQueries": ["technology"],
    "city": "New York",
    "maxItems": 200,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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 '{
  "searchQueries": [
    "technology"
  ],
  "city": "New York",
  "maxItems": 200,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call khadinakbar/meetup-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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