# Meetup Group Events Scraper - New Event Monitor (`neverempty/meetup-group-events-monitor`) Actor

Upcoming events of the Meetup groups you list, one row per event: title, link, start and end with time zone, in-person or online, venue and city, going count, capacity, fee and group. Monitoring mode remembers what was listed and returns only events that are new since the last run.

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

## Pricing

from $2.50 / 1,000 event returneds

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 Group Events Scraper - New Event Monitor

Upcoming events of the **Meetup groups you list**, one row per event: title, event page, start and end time with the time zone, in-person or online, venue name and city, how many people are going, capacity, fee, status, and the group with its member count.

- **Monitoring mode returns only new events.** Run the same groups on a schedule: the first run remembers what each group has listed, every later run returns only the events that were not listed before. A run with nothing new returns one free row that says so.
- **Asked for X, got X.** A group that Meetup does not have comes back as a `not-found` row. It is never silently replaced by another group, and every row carries the group's own id and name as Meetup gives them.
- **Give group pages, not searches.** Paste `https://www.meetup.com/your-group-name/` (an `/events/` link of the group or a language-prefixed link such as `/ja-JP/your-group-name/` also works), or just the group name.
- No login, no cookies, no proxy. Only the public group events page is read, one request at a time, and only pages Meetup's robots.txt allows.

### Use cases

- **Lead generation**: watch the groups of your industry or city and get each new event (with the venue and the group's size) the day it is announced.
- **Community and event marketing**: track what similar communities schedule, how many people go, and which events fill up.
- **Calendars and newsletters**: pull the upcoming events of a list of groups into one table every week.

### Input

```json
{
    "groups": [
        "https://www.meetup.com/dubaiwriters/",
        "https://www.meetup.com/singapore-adventurous-group/"
    ],
    "monitoringMode": false
}
```

- **`groups`** - group page addresses or group names, one per line, up to 200 per run. No default: a run reads only what you give.
- **`maxEvents`** - upper limit on event rows when monitoring is off (default 500). Groups after the limit is reached are not read.
- **`monitoringMode`** - return only events that were not listed at earlier runs.
- **`resetMonitoringState`** - forget what monitoring remembers and start again.

### What you get

| Column | Meaning |
|---|---|
| `title`, `eventUrl`, `eventId` | Event title, its page on meetup.com, and Meetup's event id |
| `startAt`, `endAt`, `timezone` | Start and end with the UTC offset as Meetup gives it (for example `2026-10-13T09:00:00+08:00`), and the group's time zone name |
| `format`, `eventType`, `isOnline` | `in-person`, `online` or `hybrid`, and Meetup's own value (`PHYSICAL`, `ONLINE`, `HYBRID`) |
| `venueName`, `venueCity`, `venueState`, `venueCountry` | The venue as shown publicly. `null` for online events, and when the organizer shows the venue to members only |
| `goingCount` | Number of people going, as shown on the event |
| `capacity` | Attendee limit set by the organizer. `null` when no limit is set (Meetup reports 0 then, which is not a real capacity) |
| `eventStatus`, `rsvpState` | `ACTIVE` or `CANCELLED` (cancelled events stay on Meetup's list, so they are returned with this status), and whether RSVPs are open (`JOIN_OPEN`, `CLOSED`, ...) |
| `feeAmount`, `feeCurrency` | The fee as set by the organizer on Meetup. `null` when the event has no fee |
| `createdAt` | When the event was created on Meetup |
| `groupName`, `groupUrlname`, `groupUrl`, `groupId` | The group, as Meetup names it |
| `groupCity`, `groupState`, `groupCountry`, `groupMemberCount`, `groupIsPrivate` | Where the group is and how many members it has |
| `listedAsOf` | The moment Meetup prepared the page that was read. Meetup can serve a group page that is a few hours old |
| `change` | Monitoring runs only: `new-event` |
| `status`, `scrapedAt` | `ok` for an event row; when the run delivered it |

A value Meetup does not give is `null`, never an empty string or a made-up 0. Attendee names, organizer names, photos and the event description are not collected.

### Monitoring mode

Turn on `monitoringMode` and schedule the same input (hourly, daily).

1. **First run of a group**: the upcoming events listed now are remembered. No event rows, nothing charged, one `baseline-saved` row per group.
2. **Later runs**: only events that were not listed before are returned (`change: "new-event"`).
3. **Nothing new**: one free `no-new-events` row, and one small monitoring check is charged for each group that was read and had nothing new.

Details that matter:

- What is remembered is kept per group (by Meetup's group id), so adding a group to a scheduled input does not reset the others; the added group starts with its own first run.
- An event is remembered by its id and also by its start time and title, so a scheduled repeat of a recurring event is not sold twice if Meetup gives it a new id.
- Monitoring ignores `maxEvents`: every new event is returned. If the maximum total charge of a run is too small for all of them, the ones that did not fit are not remembered and come in the next run.
- If a group could not be read, nothing about it is charged or changed.
- Do not schedule two runs of the same groups at the same moment: both may return the same new event.

### What is charged

- **Event returned**: one per event row.
- **Group checked**: monitoring mode only, one per group that was read and had no new event.
- Not charged: the first monitoring read of a group, rows that say a group was not found or could not be read, `no-events`, `no-new-events`, limit and budget rows. There is no start fee.

### Rows that are not events

Every run says what happened. These rows have a `status` other than `ok`, a `note` in plain English, and are free:

`not-found` (Meetup has no group with that name) · `invalid-input` (the line is not a group page, for example a search link) · `group-unreadable` / `group-blocked` (the page could not be read; the HTTP status is in `httpStatus`) · `no-events` (the group has nothing scheduled) · `baseline-saved` · `no-new-events` · `limit-reached` · `budget-reached` · `not-read` · `disallowed-by-robots` / `robots-unreadable`.

### Limits

- **Meetup shows the first 30 upcoming events on a group page.** A group with more (for example a weekly event scheduled a year ahead) returns its 30 soonest events and a free `limit-reached` row with the group's total. The rest are only reachable through Meetup's internal API, which robots.txt disallows, so this Actor does not use it. In monitoring mode, those later events are returned as new when they come inside the first 30.
- Searching Meetup by keyword or location is not offered: robots.txt disallows those search pages. Give the groups you want to follow.
- Private groups that hide their events from visitors cannot be read.
- "Upcoming" is Meetup's own list: it includes an event that has started and not ended yet (for example a trip of several days).
- Requests are sent one at a time with more than a second between them: about 2 to 3 seconds per group (36 groups took 95 seconds on 2026-10-08).
- This Actor is not affiliated with Meetup.

### Thanks for using this Actor

We build these tools for people who run them every day, and we improve them from what users tell us.

- **Missing a field, or need another filter?** Tell us in the **Issues** tab. If the data is there, we add it.
- **Found a bug or a wrong value?** Post the run ID in the **Issues** tab. Wrong data is the thing we fix first.

If this Actor saved you time, a short review helps other people find it.

# Actor input Schema

## `groups` (type: `array`):

Meetup groups to read, one per line: the group's page address (https://www.meetup.com/your-group-name/, an /events/ link of the group also works) or just the group name from that address. Each group returns its upcoming events. A group Meetup does not have comes back as a free "not-found" row; no other group is used in its place. Up to 200 groups per run.

## `maxEvents` (type: `integer`):

Upper limit on event rows when monitoring is off (earliest start time first). Groups after the limit is reached are not read. Monitoring mode ignores this number and returns every new event. Leave it as it is to get up to 500.

## `monitoringMode` (type: `boolean`):

Run the same input on a schedule. The first run of a group only remembers the upcoming events listed now (no rows, no charge). Every later run returns only events that were not listed before. A group with nothing new is charged one small monitoring check and the run returns a free "no-new-events" row.

## `resetMonitoringState` (type: `boolean`):

Clears everything monitoring mode remembers for every group before this run, so each group starts again with a first read. Leave it off for normal scheduled runs.

## Actor input object example

```json
{
  "groups": [
    "https://www.meetup.com/dubaiwriters/",
    "https://www.meetup.com/singapore-adventurous-group/"
  ],
  "maxEvents": 500,
  "monitoringMode": false,
  "resetMonitoringState": false
}
```

# Actor output Schema

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

One row per upcoming Meetup event of the groups given: title, event page, start and end time, time zone, format (in-person, online, hybrid), venue and city, going count, capacity, fee, status and the group. Groups that could not be read or were not found, runs with no new event, and runs that hit a limit come back as their own rows and are not charged.

# 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 = {
    "groups": [
        "https://www.meetup.com/dubaiwriters/",
        "https://www.meetup.com/singapore-adventurous-group/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("neverempty/meetup-group-events-monitor").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 = { "groups": [
        "https://www.meetup.com/dubaiwriters/",
        "https://www.meetup.com/singapore-adventurous-group/",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("neverempty/meetup-group-events-monitor").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 '{
  "groups": [
    "https://www.meetup.com/dubaiwriters/",
    "https://www.meetup.com/singapore-adventurous-group/"
  ]
}' |
apify call neverempty/meetup-group-events-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neverempty/meetup-group-events-monitor"
        }
    }
}
```

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/QFQChorjbn5p07F3j/builds/32aUcpzbzRs8LPXY3/openapi.json