# Meetup Events Scraper — Dates, Groups & Organizer Leads (`s-r/meetup-events`) Actor

Collect public Meetup events by city, coordinates or group. Get local dates, venues, fees, RSVP counts, group sizes and public organizer profiles with category, date and price filters.

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

## Pricing

$1.00 / 1,000 event scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

Meetup Events Scraper collects public events by city, geographic coordinates, search term, category or group calendar. Export event dates, venues, structured fees, RSVP counts and group organizer details as one row per event.

Use it to discover community events, build a local calendar, find groups that organize relevant activities, or compare upcoming events across categories. Each recurring event date is a separate row when Meetup gives it a separate event identifier. Events from overlapping result pages and overlapping group selections are deduplicated by their Meetup event ID.

### What Meetup Events Scraper returns

Each event includes its title, public URL, local start and end times with UTC offsets, event date and group time zone. Physical events include the public venue name, address, city, country code and coordinates when Meetup supplies them. Online events have empty physical location fields. A missing physical venue means the public source did not provide an address.

The group appears as `organizer_name`, matching how Meetup presents the organizing community. Additional fields include group URL, member count, home city and country, average event rating and rating count. The public group organizer person appears separately in `organizer_member_name`, with their member identifier and profile URL when available. These fields help identify the community behind an event without confusing the group with its organizer person.

### Input

Supply exactly one location method: `location`, both `latitude` and `longitude`, or `group_urls`. A place search uses the first matching place. The run output includes `resolved_location`, so you can check the selected city and country. Add a country to an ambiguous place name when necessary. Coordinate searches bypass place resolution.

In Apify Console, clear the prefilled `location` before entering coordinates or group URLs. Group URLs copied from a localized Meetup page, including `/de-DE/` and `/fr-FR/` paths, are accepted.

`radius_km` sets the geographic radius, defaults to 30 kilometers and accepts integers from 1 through 300. `max_items` defaults to 50 and accepts 1 through 1,000. It is the total number of unique events requested across all selected groups and all continuation pages, rather than a separate limit for every group.

Set `category` to a Meetup category key such as `technology`, `sports-fitness`, `career-business` or `travel-outdoor`. Categories describe the organizing group. `event_type` accepts `any`, `physical`, `online` and `hybrid`. A hybrid event retains its public physical location and is identified by the separate `event_type` field.

`keyword` uses Meetup's semantic search ranking for geographic searches. Results can be related to the topic without containing the exact word. Enable `keyword_strict` to require that text in the event title or description. In group calendars, a keyword always matches the title or description literally. `min_attendees` filters on the number of RSVPs. This count includes hosts and represents registrations, rather than verified attendance after the event.

#### Date filters and group calendars

`start_date` and `end_date` accept real calendar dates in `YYYY-MM-DD` format, with both boundary days included. Geographic searches default to today through 30 days later. The selected city's time zone determines those days. Coordinate searches default to UTC; use `timezone` to choose an IANA time zone explicitly.

Alternatively, use `date_preset`: `today`, `tomorrow`, `this_week`, `this_weekend`, `next_week` or `this_month`. Presets cannot be combined with explicit dates. The current week and current month begin today; the next week runs Monday through Sunday. Date boundaries follow daylight saving changes.

`group_urls` accepts up to ten public Meetup group URLs or group URL names. `group_events` defaults to upcoming events; use `past` for the historical calendar. Group calendars have no default date restriction. Explicit group date filters use UTC unless `timezone` is supplied and compare each event's local start date. Upcoming group events are chronological and past events are newest first. The `sort` option controls geographic searches, where it accepts `date` or `relevance`.

### Output

The default dataset contains one event per row. Stable fields include `source`, `fetched_at`, `platform`, `event_id`, `title`, `url`, `start`, `end`, `start_date`, `timezone`, `is_online`, location fields, `organizer_name`, `category`, price fields and availability flags. Additional event and group fields preserve public descriptions, images, topic keys, RSVP state, capacity and group statistics.

`price_min` and `price_max` contain the same single structured event fee in `currency`. They are amounts in the reported currency, not cents. When Meetup supplies no structured fee, the event is marked free, both price fields are zero and currency is empty. A price mentioned only in a description is not detected. Multiple ticket levels are not available. `fee_required` and `fee_accepts` preserve the source payment conditions when a fee is supplied.

`is_sold_out` identifies full or waitlisted RSVP states. `tickets_available` identifies open registration states; it can be false when registration has closed or has not yet opened. A closed registration state does not by itself mean the event sold out.

The run's `OUTPUT` record contains counts, `partial`, warnings and the resolved place. Large or interrupted collections can continue internally across several pages. The actor follows continuation automatically. API consumers receive `next_cursor` and should repeat the same input with that cursor until it is empty. A partial response preserves events already collected. If a source stops repeating useful pages, the output explains the stop.

#### Example output

A real row from an Amsterdam search (description and image fields left out for length):

```json
{
  "event_id": "316921063",
  "title": "ATAC Indoor Swim training - entrance on the ATAC web shop",
  "url": "https://www.meetup.com/atac-amsterdam-triathlon-and-cycling/events/316921063/",
  "start": "2026-10-30T07:00:00+01:00",
  "end": "2026-10-30T08:00:00+01:00",
  "timezone": "Europe/Amsterdam",
  "is_online": false,
  "venue_name": "Sportplaza Mercator",
  "address": "Jan van Galenstraat 315",
  "city": "Amsterdam",
  "country_code": "NL",
  "lat": 52.371708,
  "lng": 4.846011,
  "organizer_name": "ATAC - Amsterdam Triathlon And Cycling",
  "category": "Sports & Fitness",
  "price_min": 0,
  "price_max": 0,
  "currency": null,
  "is_free": true,
  "attendees": 2,
  "max_attendees": 30,
  "event_type": "PHYSICAL",
  "group_url": "https://www.meetup.com/atac-amsterdam-triathlon-and-cycling",
  "group_members": 420,
  "group_rating": 4.87,
  "organizer_member_name": "ATAC Triathlon & Cycling Club"
}
```

### Use cases for a Meetup events scraper

- **Lead generation:** list the groups that organize events in your niche, with member counts, ratings and the public organizer profile, then contact the communities that fit your offer.
- **Community marketing:** find where your audience meets in a city, which categories are busiest and which groups grow, before choosing where to sponsor or speak.
- **Event aggregators:** feed a local calendar or newsletter with dated, geocoded events, filtered by category, price and online or physical format.
- **Market research:** compare the number of upcoming events and RSVPs per city or topic over time.

### Meetup Events Scraper compared with other Meetup scrapers

Other Meetup scrapers on the Store mostly return a flat list of events. This actor is built around a stable, documented row: one event per row with the group as organizer, a structured fee in a single currency, RSVP counts, and explicit date filters in the selected city's time zone. It also accepts coordinates, a keyword with optional strict matching, category and event-type filters, and group calendars including past events. Results continue across pages with a cursor, overlapping pages are deduplicated by event ID, and you pay only for rows that reach the dataset.

### Pricing

Billing uses one `event` charge per event actually delivered to the dataset. Empty results have no event charges. Duplicate events are not charged again within the same collection. Check the actor's Pricing tab for the current event price and any platform usage charges. This actor has no custom run-start charge.

Non-paying Apify accounts can receive up to ten event rows per run. This is a delivery cap; the normal event price still applies. Paying accounts can request the full `max_items` range. The same delivered-row count controls the event charge, including when only part of a larger request could be completed.

### FAQ

#### Does a keyword require an exact match?

Geographic keyword searches use semantic relevance by default. Enable `keyword_strict` for a literal title or description match. Group calendar keywords always use literal matching.

#### Can I collect past group events?

Yes. Supply the group's URL or URL name in `group_urls` and set `group_events` to `past`. Add explicit date filters if you need a narrower period. This reads the public calendar, not private group member information.

#### Why is an address or price missing?

Some organizers share addresses only with members. Online events have no physical address in this output. Prices are limited to Meetup's structured fee; text inside an event description is not converted into a ticket price.

#### How do I identify repeated events?

Use `platform` together with `event_id` as the event key. Recurring series have a separate `series_id` when provided, while each published date remains its own event row. Public calendars change over time, so independently started runs can contain the same event.

# Actor input Schema

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

City or place name. Uses the first matching location; resolved_location reports the choice.

## `latitude` (type: `number`):

Latitude, supplied together with longitude instead of location. In Apify Console, clear the prefilled location before entering coordinates.

## `longitude` (type: `number`):

Longitude, supplied together with latitude.

## `radius_km` (type: `integer`):

Search radius in kilometers; converted to source miles.

## `group_urls` (type: `array`):

One to ten public Meetup group URLs or urlnames, including localized URLs. Exclusive with location and coordinates. In Apify Console, clear the prefilled location before entering group URLs.

## `group_events` (type: `string`):

Group calendar selection. Applies only with group_urls; omitted means upcoming.

## `keyword` (type: `string`):

Semantic search ranking, not an exact keyword filter. For groups, matches title or description literally.

## `keyword_strict` (type: `boolean`):

Also require the keyword in title or description. Requires keyword.

## `category` (type: `string`):

Group topic category.

## `event_type` (type: `string`):

Event attendance mode.

## `start_date` (type: `string`):

Inclusive local start date YYYY-MM-DD. Search default: today. Group calendars have no default date restriction.

## `end_date` (type: `string`):

Inclusive local end date YYYY-MM-DD. Search default: start date plus 30 days.

## `date_preset` (type: `string`):

Convenient local date window; cannot be combined with explicit dates.

## `timezone` (type: `string`):

IANA time zone for date filters. Default: resolved city time zone, or UTC for coordinates and group date filters.

## `sort` (type: `string`):

Search ordering. Group upcoming events are chronological; past events are newest first.

## `price` (type: `string`):

Filter using the structured event fee. Prices mentioned only in descriptions are not detected.

## `min_attendees` (type: `integer`):

Minimum RSVP count, applied after retrieval.

## `max_items` (type: `integer`):

Maximum total unique events across all groups and cursor pages.

## `cursor` (type: `string`):

Opaque next_cursor from a previous response. Keep every other input field identical.

## Actor input object example

```json
{
  "location": "Amsterdam",
  "radius_km": 30,
  "keyword_strict": false,
  "event_type": "any",
  "sort": "date",
  "price": "any",
  "min_attendees": 0,
  "max_items": 50
}
```

# Actor output Schema

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

One row per unique public Meetup event.

## `output` (type: `string`):

Run status, warnings and delivered event count.

# 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": "Amsterdam"
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/meetup-events").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": "Amsterdam" }

# Run the Actor and wait for it to finish
run = client.actor("s-r/meetup-events").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 '{
  "location": "Amsterdam"
}' |
apify call s-r/meetup-events --silent --output-dataset

```

## MCP server setup

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

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/peApcmCHY2K3PgIcE/builds/BqHFiIZSPjSWkCEr3/openapi.json