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

Collect public Meetup events matching your keywords and locations. Each record can include its title, schedule, description, event type, RSVP count, venue, fee, hosts and hosting group details. Search by date range and radius, and choose physical, online or any event type.

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

## Pricing

from $2.38 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Meetup Events Scraper

**Returns:** one row per Meetup event with id, title, dateTime, venueName, rsvpCount, groupName and sourceUrl.
**Input:** `{"searchQueries": ["networking"], "locations": ["New York"], "maxItems": 20}`
**Best for:** local event calendars, lead lists from event hosts and organizers, and monitoring RSVP counts per topic.

```json
{
  "id": "316887260",
  "title": "Networking",
  "dateTime": "2026-10-20T19:00:00-04:00",
  "venueName": "Online event",
  "rsvpCount": 3,
  "groupName": "Networking and New Connections",
  "sourceUrl": "https://www.meetup.com/networking-and-new-connections/events/316887260/"
}
```

### What does Meetup Events Scraper do?

Meetup Events Scraper collects public event listings from Meetup for the keywords, cities and dates you choose. You give it search terms such as "python" or "networking" and one or more cities. It looks up each city, searches Meetup within the radius you set, and returns one clean record per event. Each record has the event title, start and end time, description, RSVP count, venue, ticket fee, the hosting group, the group's member count, the event hosts and the group organizer.

The Actor reads the same public data that the Meetup website shows to visitors who are not signed in. It needs no login, no cookies and no API key. It runs one request per second and retries politely when Meetup is slow, so it is safe to schedule.

Build upcoming event calendars, compare RSVP counts by topic, and collect public hosts and organizers for sponsorship research. Schedule runs to monitor new events.
This Actor is an independent tool. It is not affiliated with or endorsed by Meetup.

### What data can you get?

Every event is one dataset item. Fields that Meetup does not provide for an event (for example a venue for an online event, or a fee for a free event) are returned as null.

| Field | Type | Description |
|---|---|---|
| `id` | string | Stable numeric Meetup event ID, as a string. |
| `sourceUrl` | string | Public Meetup page the record came from. |
| `title` | string | Event title. |
| `dateTime` | string | Event start as ISO 8601 with the local UTC offset. |
| `endTime` | string | Event end as ISO 8601 with the local UTC offset. |
| `description` | string | Event description text, Markdown as written by the organizer. |
| `eventType` | string | PHYSICAL, ONLINE or HYBRID as reported by Meetup. |
| `isOnline` | boolean | True for online-only events. |
| `eventUrl` | string | Link to the event page on Meetup. |
| `rsvpCount` | number | Number of members who RSVP'd yes (going). |
| `maxTickets` | number | RSVP limit set by the organizer; 0 means no cap. |
| `rsvpState` | string | Meetup RSVP state such as JOIN_OPEN or JOIN_APPROVAL. |
| `venueName` | string | Venue name; online events show Meetup's placeholder "Online event". |
| `venueAddress` | string | Venue street address. |
| `venueCity` | string | City of the venue. |
| `venueState` | string | State or region code of the venue. |
| `venueCountry` | string | Two-letter lowercase country code. |
| `venueLatitude` | number | Venue latitude in decimal degrees. |
| `venueLongitude` | number | Venue longitude in decimal degrees. |
| `feeAmount` | number | Ticket fee; null for free events. |
| `feeCurrency` | string | Currency of the fee. |
| `groupName` | string | Name of the hosting Meetup group. |
| `groupUrlname` | string | URL slug of the group. |
| `groupUrl` | string | Link to the group page. |
| `groupMemberCount` | number | Number of members in the group. |
| `groupCity` | string | Home city of the group. |
| `groupState` | string | State or region code of the group. |
| `groupCountry` | string | Two-letter lowercase country code of the group. |
| `groupFoundedDate` | string | Date the group was founded (needs group details). |
| `groupTopic` | string | Meetup topic category of the group (needs group details). |
| `hosts` | array | Event hosts as {id, name, memberUrl}. |
| `organizerName` | string | Public name of the group organizer, or first event host. |
| `organizerUrl` | string | Public Meetup profile URL of the organizer. |
| `imageUrl` | string | Event cover photo URL. |
| `searchQuery` | string | Keyword that found this event. |
| `searchLocation` | string | City input that found this event. |
| `eventCategory` | string | AI category: tech, business-networking, social, health-fitness, arts-culture, education, hobby, other. Only with enrichWithAI. |
| `leadRelevance` | string | AI rating high, medium or low for B2B outreach. Only with enrichWithAI. |

Online events have no real venue, so the address, city, state, country and coordinates are null for them and `isOnline` is true. Hybrid events keep their venue and are reported with the event type HYBRID.

### How to use

1. Open the Actor on Apify and go to the Input tab.
2. Add one or more search keywords, for example "networking".
3. Add one or more cities, for example "New York". You can add a country or state code after a comma, such as "Paris, fr", when a city name exists in several places.
4. Optionally set the date range, the radius, the event type and the maximum number of events.
5. Click Start. Results appear in the Output tab as soon as the first page is read, and you can download them as JSON, CSV, Excel or HTML.

Each keyword is searched in every city, so two keywords and three cities make six searches. Results are sorted by Meetup's relevance ranking and each event is returned once, even when it appears in several searches or on several result pages.

#### Tips

Use specific keywords such as "react" or "language exchange". Meetup search is fuzzy, so very broad words can bring in loosely related events. Strict keyword match is on by default and keeps events whose title, description or group text contains every token of the current search phrase (tokens shorter than two characters are ignored); turn it off to keep all fuzzy matches. Use the date range to look ahead. Without it the Actor returns events starting from now. Turn off group details for a faster run. With it on, the Actor makes one extra request for each unique group to add the founded date, topic and organizer. To follow a few specific groups, put their URLs or urlnames in the group filter.

### Input

| Field | Type | Description |
|---|---|---|
| `searchQueries` | array | Keywords to search for. Required. |
| `locations` | array | City names to search around. Required. |
| `maxItems` | integer | Maximum events to return across all searches, 1-5000, default 50. |
| `radiusMiles` | integer | Search radius around each city centre, 1-500, default 25. |
| `dateFrom` | string | Earliest start date, ISO format. Empty means now. |
| `dateTo` | string | Latest start date, ISO format. Empty means no end date. |
| `eventType` | string | ANY, PHYSICAL or ONLINE. Default ANY. |
| `groupUrls` | array | Keep only events from these groups (URLs or urlnames). |
| `eventUrls` | array | Meetup event URLs or numeric IDs to fetch directly. They are fetched first, then the keyword search runs, and both share the single `maxItems` limit. Nonempty `searchQueries` and `locations` remain required. The group filter applies, but search dates, event type and keywords do not filter direct lookups. For these records `searchQuery` and `searchLocation` are null. |
| `includeGroupDetails` | boolean | Fetch founded date, topic and organizer for each group. Default true. |
| `includeDescription` | boolean | Return the full description text. Default true. |
| `strictKeywordMatch` | boolean | Keep only events that contain a keyword. Default true. |
| `enrichWithAI` | boolean | Add an AI category and lead relevance to each event. The input editor defaults to true; API calls omitting this field use false. Set it explicitly. |
| `proxyConfiguration` | object | Apify Proxy settings. Default is no proxy. |

Example input:

```json
{
  "searchQueries": ["python"],
  "locations": ["Berlin"],
  "dateFrom": "2026-10-10",
  "dateTo": "2026-12-31",
  "eventType": "ONLINE",
  "radiusMiles": 25,
  "includeGroupDetails": true,
  "maxItems": 30
}
```

The Actor stops as soon as `maxItems` events are saved and never returns more than that. If a city cannot be found, it logs a warning and moves on to the next one. If nothing matches, the run finishes successfully with zero items and a status message. Broaden the keyword, increase radiusMiles, widen the date range, choose eventType ANY or set strictKeywordMatch false. Unknown cities should be replaced with recognised city names. Persistent blocks suggest enabling proxyConfiguration or trying another target. Missing required keywords or cities fail input validation before requests.

### Output

This is a real item from a local run. The description is shortened here.

```json
{
  "id": "316887260",
  "sourceUrl": "https://www.meetup.com/networking-and-new-connections/events/316887260/",
  "title": "Networking",
  "dateTime": "2026-10-20T19:00:00-04:00",
  "endTime": "2026-10-20T20:00:00-04:00",
  "description": "**Looking to make meaningful new connections and expand your network? Join us for a welcoming networking event where professionals, entrepreneurs, and community-minded individuals come together to build relationships, share ideas, and create opportunities. Whether you're looking for new friends, bus…",
  "eventType": "ONLINE",
  "isOnline": true,
  "eventUrl": "https://www.meetup.com/networking-and-new-connections/events/316887260/",
  "rsvpCount": 3,
  "maxTickets": 0,
  "rsvpState": "JOIN_OPEN",
  "venueName": "Online event",
  "venueAddress": null,
  "venueCity": null,
  "venueState": null,
  "venueCountry": null,
  "venueLatitude": null,
  "venueLongitude": null,
  "feeAmount": null,
  "feeCurrency": null,
  "groupName": "Networking and New Connections",
  "groupUrlname": "networking-and-new-connections",
  "groupUrl": "https://www.meetup.com/networking-and-new-connections",
  "groupMemberCount": 867,
  "groupCity": "New York",
  "groupState": "NY",
  "groupCountry": "us",
  "groupFoundedDate": null,
  "groupTopic": null,
  "hosts": [
    {
      "id": "128185132",
      "name": "Podcast Creator Ian Tolson",
      "memberUrl": "https://www.meetup.com/members/128185132/"
    }
  ],
  "organizerName": "Podcast Creator Ian Tolson",
  "organizerUrl": "https://www.meetup.com/members/128185132/",
  "imageUrl": "https://secure.meetupstatic.com/photos/event/9/a/f/2/highres_536499666.jpeg",
  "searchQuery": "networking",
  "searchLocation": "New York",
  "eventCategory": null,
  "leadRelevance": null
}
```

The dataset has an overview view with the most useful columns: title, start time, event type, RSVP count, venue name and city, fee, group name, group member count, organizer and links. You can switch to the full view or download all fields.

### How much does it cost?

You pay per result: each event saved to the dataset is one result. If you turn on AI enrichment, events that were successfully enriched are billed as an additional enriched result. Events that could not be enriched are not billed for enrichment. See the Pricing tab of the Actor for the current rates. Platform usage such as compute is covered by the Apify plan you already have.

You control spend with `maxItems`: the Actor never saves more events than you ask for and never charges for more.

### Use with AI agents (MCP)

You can call this Actor from any MCP-compatible assistant through the Apify MCP server. Add this to your MCP client configuration:

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

Example prompts:

- "Find 20 upcoming python meetups in Berlin in the next two months and list their groups."
- "Which networking events in New York next week have the highest RSVP counts?"
- "List online events about data science starting in November and show the organizers."

The agent sees the input schema, so it passes keywords, cities and the item limit directly.

### Integrations and API

You can run the Actor from code, from a schedule, or through integrations such as Zapier, Make, Google Sheets and webhooks. Use the Apify API client of your choice.

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("axiomworks/meetup-events-scraper").call(run_input={
    "searchQueries": ["python"],
    "locations": ["Berlin"],
    "maxItems": 30,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["dateTime"], item["rsvpCount"])
```

**JavaScript**

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('axiomworks/meetup-events-scraper').call({
    searchQueries: ['python'],
    locations: ['Berlin'],
    maxItems: 30,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((e) => process.stdout.write(`${e.title}\n`));
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~meetup-events-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries": ["python"], "locations": ["Berlin"], "maxItems": 30}'
```

### FAQ

**Do I need a Meetup account or API key?**
No. The Actor only reads public data and never logs in.

**Why do I sometimes get events that do not mention my keyword?**
Meetup's search ranks by relevance and can include related events, especially in smaller cities. Strict keyword match is on by default; turn it off to see all related events.

**Why is the venue empty?**
Online events show Meetup's placeholder "Online event" as the venue name. Some in-person events have no venue at all. These fields are null instead of guessed.

**Why is the RSVP count low or zero?**
Newly created events often have few RSVPs. The count is what Meetup shows at the time of the run.

**What does maxTickets mean?**
It is the RSVP limit set by the organizer. It is 0 when the event has no limit.

**Can I get member emails or attendee lists?**
No. The Actor returns only public information: the host names and public profile links. It does not return emails or private data.

**What is the AI enrichment?**
When enabled, event titles and descriptions are sent to a third-party AI processor, which returns an event category and a lead relevance rating. If the processor is unavailable, the events are still returned without these two fields and are not billed for enrichment.

**How fast is it?**
Requests remain sequential, at most one per second. The prefill returned 20 events in approximately 7 seconds in a local check. Results depend on keyword relevance, Meetup response times and optional group or AI requests. Repeated identical keywords and cities are searched once. When direct event URLs or IDs fill maxItems, no city lookup or search is made.

**What happens if Meetup blocks a search or a city lookup fails?**
The failed target is logged and other targets continue. Requests share an 80-second initial budget until the first result, including timeouts and retry waits. A blocked response triggers datacenter proxy fallback on Apify, with fresh sessions for retries. If no events are saved, the run succeeds with a status explaining what to change. A malformed required input still fails validation.

**The run found fewer events than maxItems. Why?**
Meetup returned fewer matching events for your keywords, city, radius and dates. Widen the radius or the date range.

### Is it legal to scrape Meetup?

The Actor collects only information that Meetup shows publicly without a login. It does not bypass logins or access controls and returns no private data such as emails. Public event details are generally considered fair game, but you are responsible for how you use the data. Respect privacy laws such as the GDPR when you store or process names of hosts and organizers, and check Meetup's terms for your use case. If you are unsure, ask a lawyer.

### Feedback

If a field is missing, a search behaves oddly or you need another option, open an issue from the Actor page on Apify. Reports with an example input and the run link are the easiest to act on.

# Actor input Schema

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

Required keyword strings, e.g. \["networking", "python"]. Each keyword is searched in every locations city. With strictKeywordMatch true, every keyword token must occur in the title, description or group text. Keep this nonempty even when supplying eventUrls.

## `locations` (type: `array`):

Required city strings, e.g. \["New York", "Berlin, DE"]. Each is resolved to coordinates for every searchQueries keyword. An optional comma-separated state or country code helps disambiguate. Unknown cities are skipped; use another city. Required even with eventUrls.

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

Maximum unique events across eventUrls and all keyword/city searches combined, integer 1-5000, default 50, e.g. 20. Direct events use the budget first. Fewer results are returned when targets have no more matches.

## `radiusMiles` (type: `integer`):

Integer search radius in miles around each locations city, 1-500, default 25, e.g. 10. Applies to keyword searches, not direct eventUrls. Increase it to include events farther from the city.

## `dateFrom` (type: `string`):

Earliest start for keyword search results, e.g. "2026-11-01" or "2026-11-01T12:00:00Z". A date-only value starts at midnight UTC. Empty or omitted starts from now. Does not filter direct eventUrls.

## `dateTo` (type: `string`):

Latest start for keyword search results, e.g. "2026-12-31" or "2026-12-31T18:00:00Z". A date-only value includes the full UTC day. Empty or omitted sets no end date. Does not filter direct eventUrls.

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

Choose ANY (default) for all search event types, PHYSICAL for in-person events, or ONLINE for online events, e.g. "ONLINE". Applies to keyword searches, not direct eventUrls. Use ANY if a search is too narrow.

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

Optional group URL or slug strings, e.g. \["rust-nyc", "https://www.meetup.com/pyladies-nyc/"]. Keep only matching groups in both direct events and keyword search results; this does not discover group events independently. Empty or omitted keeps all groups.

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

Optional Meetup event URL or numeric ID strings, e.g. \["https://www.meetup.com/rust-nyc/events/316698929/", "316698929"]. Fetched before keyword searches and shares maxItems. searchQueries and locations remain required. groupUrls still applies; keyword, date and eventType search filters do not.

## `includeGroupDetails` (type: `boolean`):

Boolean, default true, e.g. false for a faster run. Fetch each unique group once to add groupFoundedDate, groupTopic and organizer details. Basic groupName and groupMemberCount are already in event data. The daily prefill uses false.

## `includeDescription` (type: `boolean`):

Boolean, default true, e.g. false to return description as null for smaller output. Keyword matching still uses the source description when this is false.

## `strictKeywordMatch` (type: `boolean`):

Boolean, default true. Require every token of each search keyword in the event title, description or group text; tokens shorter than two characters are ignored. Set false, e.g. false, to keep Meetup fuzzy matches. Direct eventUrls are not keyword-filtered.

## `enrichWithAI` (type: `boolean`):

Boolean, e.g. true to request eventCategory and leadRelevance from a third-party AI processor. The input editor defaults to true; API calls omitting this field use false. Set it explicitly for consistent results. Processor errors leave enrichment null; successful enrichment uses the enriched-result event.

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

Proxy object, e.g. {"useApifyProxy": true}. Default {"useApifyProxy": false} requests Meetup directly; cloud runs retry blocked requests through Apify datacenter proxy. For persistent blocks, enable proxyConfiguration or try another target. Local runs use no proxy.

## Actor input object example

```json
{
  "searchQueries": [
    "networking"
  ],
  "locations": [
    "New York"
  ],
  "maxItems": 20,
  "radiusMiles": 25,
  "eventType": "ANY",
  "includeGroupDetails": true,
  "includeDescription": true,
  "strictKeywordMatch": true,
  "enrichWithAI": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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": [
        "networking"
    ],
    "locations": [
        "New York"
    ],
    "maxItems": 20,
    "eventType": "ANY",
    "includeGroupDetails": false,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/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": ["networking"],
    "locations": ["New York"],
    "maxItems": 20,
    "eventType": "ANY",
    "includeGroupDetails": False,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/meetup-events-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 '{
  "searchQueries": [
    "networking"
  ],
  "locations": [
    "New York"
  ],
  "maxItems": 20,
  "eventType": "ANY",
  "includeGroupDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call axiomworks/meetup-events-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,axiomworks/meetup-events-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/lCDqhrNgWQ74X5jwA/builds/X1a0e77c78hK5FbKV/openapi.json