Meetup API Alternative: Event and Group Data After the Lockdown

For years Meetup had one of the friendliest open REST APIs around — a simple key, generous endpoints for groups, events, and members, and a thriving ecosystem of apps built on top of it. That era is over. Meetup deprecated the open REST API and consolidated everything behind a GraphQL API that is effectively gated: meaningful access is tied to Meetup Pro (an organizer subscription) and OAuth, and the old “grab a key and query any group” workflow is gone. If you’re doing community research, building an events aggregator, or running event-based lead generation, you’ve hit the same wall everyone hits. This guide covers the realistic Meetup API alternative in 2026: getting event and group data from Meetup’s public pages.

What changed and why it matters

The practical state of the official API:

• The legacy REST API that powered countless integrations was retired. Endpoints that used to return group and event lists for any public group are gone.
• The replacement is a GraphQL API, but it’s organizer-and-partner oriented. Useful scopes are bound to authenticated accounts, and the genuinely open, query-anything access tier doesn’t exist the way it used to. Meetup Pro — a paid organizer plan — is the path to the broader data, and it’s priced for organizers, not for analysts pulling other people’s groups.

So the typical asks — “list all tech meetups in Berlin,” “get the upcoming events and RSVP counts for these 50 groups,” “pull the organizer and member counts across a category” — no longer have a clean, free, self-serve API path. That’s the gap the public-page approach fills.

What data is actually available

Meetup’s public pages are rich and, importantly, server-render structured data:

• Groups: name, slug/URL, description, topic tags, city/region, member count, organizer, founding date.
• Events: title, date/time, timezone, venue (or “online”), description, RSVP/attendee count, going status, host.
• Discovery: category and city listing pages that enumerate groups and upcoming events.
• Organizer / host: public organizer name and profile link where shown.

Member-level personal data is mostly behind login and is the sensitive part — for lead-gen and research, the value is in groups, events, and organizers, which are public.

How the public surface works

Two things make Meetup pleasant to work with compared to heavily defended targets:

1. Embedded JSON. Meetup is a server-rendered app that ships a hydration payload in the page (a __NEXT_DATA__-style JSON blob plus JSON-LD Event and Organization objects). Most of what you want — event title, ISO start time, venue, attendee count, group member count — is parseable directly from that embedded JSON without executing the client app. JSON-LD in particular gives you clean, schema.org-typed event data.
2. Predictable URL patterns. Groups live at meetup.com/<group-slug>/, events at meetup.com/<group-slug>/events/<event-id>/, and discovery at meetup.com/find/?... with location and topic parameters. That makes crawling a category or city deterministic: hit discovery, collect group slugs, then enumerate each group’s events page.

The crawl shape is: discovery page → group pages → event pages, parsing the embedded JSON at each level.

Rate limits and how to live with them

There’s no published quota for the public site, so you live inside ordinary politeness limits:

• Meetup is far less aggressive than the OTA-class sites, but bursts from one IP still earn throttling. Keep concurrency modest.
• Parse the embedded JSON instead of rendering — it’s faster, lighter, and less likely to trip detection than driving a full browser.
• Cache group metadata (member count changes slowly) and refresh only the events list, which is the part that moves.
• For multi-city sweeps, rotate IPs and pace the discovery crawl rather than firing every city at once.

A clean output schema

Normalize an event into a row that carries its group context:

{
  "event_id": "298734512",
  "event_url": "https://www.meetup.com/berlin-js/events/298734512/",
  "title": "Berlin.js — June Meetup",
  "start_time": "2026-06-18T18:30:00+02:00",
  "timezone": "Europe/Berlin",
  "is_online": false,
  "venue_name": "Tech Hub Berlin",
  "venue_city": "Berlin",
  "venue_country": "DE",
  "attendee_count": 142,
  "description": "Talks on JS tooling and ...",
  "group": {
    "name": "Berlin.js",
    "slug": "berlin-js",
    "url": "https://www.meetup.com/berlin-js/",
    "member_count": 9120,
    "topics": ["javascript", "web development"],
    "organizer": "Jane Doe"
  },
  "scraped_at": "2026-06-06T12:00:00Z"
}

▶ Try the Meetup Scraper on Apify — events, RSVP counts, group sizes, and organizers from any city or category, no Pro subscription. No auth required.

Use cases

• Event-based lead generation — find active local communities and the organizers running them, by topic and city.
• Community and ecosystem research — map how many active groups and events exist in a niche or region over time.
• Sponsorship targeting — identify high-attendance recurring events worth sponsoring or speaking at.
• Developer relations — DevRel teams track where their audience gathers and which meetups are growing.
• Local events aggregators — feed “what’s on this week” listings from structured event data.

Build it yourself vs. a managed actor

DIY is more achievable here than on hostile sites — the embedded JSON does most of the work. The friction is in coverage and durability: handling discovery pagination, online vs. in-person venue shapes, recurring-event series, deleted/postponed events, and the inevitable day Meetup reshapes its __NEXT_DATA__. Budget a couple of days for a clean crawler, plus light maintenance.

A managed actor handles the crawl shape and JSON parsing and hands you the normalized rows. For a one-off research pull, build it; for a recurring lead-gen or DevRel feed, the managed actor is the lower-maintenance Meetup API alternative.

Common pitfalls

• Timezones — event times are local; always capture the timezone and store an offset-aware ISO timestamp or your “upcoming” filters will misfire.
• Online events have no venue — branch your parser; don’t assume a venue object exists.
• Attendee count vs. capacity — RSVP/going count isn’t the room cap. Capture what’s shown and label it.
• Recurring series — a weekly meetup is many event IDs sharing a group. Key on event_id, not title.
• Postponed/cancelled — these still render; capture the status so you don’t count dead events as active.

Wrapping up

Meetup retired the open REST API and pushed its data behind a Pro-gated GraphQL API, breaking the old grab-a-key-and-query workflow. The working Meetup API alternative in 2026 is the public site: discovery pages to enumerate groups, then group and event pages whose embedded JSON-LD gives you clean, structured event and group data. It’s a forgiving surface compared to the OTA giants, and a managed scraper turns it into ready-to-use rows if you’d rather skip the crawler maintenance.

▶ Open the Meetup Scraper on Apify — structured event and group data after the API lockdown, ready for ETL or outreach. Pay per result.