Meetable

An open-source events aggregator for communities that want to own their public calendar. Honestly reviewed.

TL;DR

• What it is: A minimal, self-hosted events listing and aggregation website — think a public community calendar page you fully control, not a scheduling or ticketing tool [1].
• Who it’s for: Community organizers, developer groups, and non-technical founders running recurring public events who are tired of paying Meetup.com or relying on Luma’s SaaS infrastructure.
• Cost savings: Meetup.com charges organizers $12–23/month. Meetable runs on any PHP/MySQL server — shared hosting from $3–5/month covers it.
• Key strength: Exceptional IndieWeb integration (webmentions, iCal feeds, RSVP support) and a genuinely minimal feature surface that stays out of your way [README].
• Key weakness: 163 GitHub stars, one primary maintainer, no Docker image, no SaaS fallback. This is a solo-dev project, and the deployment path assumes you can configure nginx and PHP yourself [README].
• Honest framing: Meetable is not a Calendly replacement, not a ticketing platform, and not a team scheduling tool. It is a public community events page that happens to be open source and self-hostable.

---

What is Meetable

Meetable is a PHP/Laravel application that displays a list of upcoming events, archives past ones, and lets logged-in users RSVP, upload photos, and add event pages with rich metadata. That’s the whole pitch.

Aaron Parecki — one of the architects of IndieWeb standards and the author of OAuth 2.0 Simplified — built it in January 2020 because the IndieWeb community needed a home for its events that wasn’t dependent on Meetup.com or Facebook [1]. The project started as a private internal tool and was open-sourced almost immediately after launch. Within weeks of going live as events.indieweb.org, the community had hosted 7 events and scheduled 15 more [1].

Live instances tell you a lot about who actually uses this. Three are running in the wild and publicly linked from the README: events.indieweb.org for the IndieWeb community, events.oauth.net for the OAuth/OIDC ecosystem, and meet.modelcontextprotocol.io for the Model Context Protocol community [README]. These are all tightly-scoped developer and standards communities that want a persistent, searchable, subscribable events page they control. That’s Meetable’s actual audience.

What it explicitly is not: there’s no payment processing, no ticket sales, no seat limits, no waitlists, no video conferencing integration, no email reminders, no CRM for attendees. It’s a public-facing community calendar with a clean admin interface. If you need any of those other things, you’ll be writing custom code or combining it with something else.

---

Why people choose it

The reference points here are limited because Meetable occupies an unusually specific niche. Third-party reviews don’t exist in the way they do for productivity tools — which itself is informative. This is tooling that the IndieWeb and standards communities talk about amongst themselves, not something that gets Product Hunt launches and comparison blog posts.

Versus Meetup.com. The obvious migration path. Meetup.com charges organizers $12.99–$23.99/month for groups beyond the free tier, has repeatedly raised prices and changed its model, and has been in decline since WeWork acquired and then sold it. The IndieWeb community moved precisely because of this dependency risk [1]. You can’t export your events list and move somewhere else when Meetup decides to restructure pricing again. With Meetable, you own the data, the domain, and the infrastructure.

Versus Luma. Luma (lu.ma) is the current default for community events among developer communities — it has a better free tier than Meetup and a cleaner UI. The trade-offs are familiar: it’s VC-backed SaaS with no export path, your attendee data lives on their servers, and the free tier can change. Meetable’s answer is the same as any self-hosted tool: no vendor lock-in, full data ownership, no per-attendee fees.

Versus Eventbrite. Not a fair comparison. Eventbrite is a ticketing platform with discovery features. Meetable has no ticketing. The overlap is only in the “list of upcoming events” feature slice.

The IndieWeb angle. This is where Meetable actually differentiates. It supports webmentions natively, which means someone can write a blog post about an event, send a webmention to the event page, and their notes or photos appear on the event’s permalink automatically [README]. No other event listing tool does this. For communities that care about the decentralized web (and Meetable’s user base does), this is a first-class feature, not an afterthought.

The iCal angle. Every list of events in Meetable — the home page, tag pages, individual event streams — has an iCal feed. Subscribe to that feed in your calendar app of choice and you get updates without touching the website [README]. This sounds minor but it’s genuinely useful for communities that publish a high volume of events across time zones.

---

Features

Based on the README and the January 2020 launch post:

Discovery and browsing:

• Upcoming events on the home page, archive view of past events [README]
• Tag system with a “discover” page — tags weighted by multi-city usage appear first, city-specific tags sorted alphabetically [1]
• “Significant tags” (used by two or more upcoming events) surfaced on the home page to avoid dead-end clicks [1]

Event pages:

• Permalink per event with: cover photo, name, date/time, location, external website link, ticket URL, markdown/HTML description, timezone converter link [README]
• RSVP button for logged-in users [README]
• Photo upload for logged-in users [README]
• Webmention support — external posts and notes can be added to event pages from other websites [README]
• “Add to Calendar” — exports iCal file or links to Google Calendar [README]

iCal feeds:

• All event lists have iCal feeds (home page, tag pages, etc.) [README]

Authentication (multiple methods):

• Passkey (single-user admin mode, no external dependencies)
• GitHub OAuth
• OpenID Connect (OIDC)
• Vouch (reverse proxy header-based SSO)
• Heroku (for Heroku-deployed instances)
• Configurable whether login/logout links appear in the nav [README]

Infrastructure:

• MySQL/MariaDB storage [README]
• Optional Redis for queue work [README]
• REST API (listed in features) [merged profile]
• SSO support (listed in features) [merged profile]
• Timezone support [merged profile]

What’s not here: email reminders, recurring event templates, attendee management, ticket sales, Zoom/Meet integration, analytics.

---

Pricing: SaaS vs self-hosted math

Meetable has no SaaS tier. There’s no paid cloud version, no hosted option, no freemium. It’s install-it-yourself or nothing.

Meetable self-hosted:

• Software license: $0 (MIT) [README][1]
• Hosting: a shared PHP host ($3–5/month) or a small VPS ($5–10/month)
• Domain: $10–15/year

Meetup.com for comparison:

• Organizer Basic: $12.99/month
• Organizer Standard: $23.99/month
• Free tier: limited to viewing, not organizing

Luma for comparison:

• Free tier: unlimited events, basic features, Luma branding on emails
• Pro: $29/month — custom domains, email customization, more analytics

Concrete savings for a community organizer:

If you’re running a local developer group on Meetup.com Standard, you’re paying $288/year. Meetable on a shared PHP host is $36–60/year in hosting plus a domain. Rough annual saving: $230–250/year — not huge, but communities running events for years aren’t burning hundreds of dollars for this if they don’t have to.

The more compelling case is control and longevity. Meetup.com has restructured pricing four times in the last decade. Luma is VC-funded and pre-profitability. Meetable running on your own infrastructure doesn’t have a pricing page that can change.

---

Deployment reality check

This is where honest review matters most for a tool aimed at non-technical founders. Meetable’s deployment is not Docker-friendly and is notably more involved than a docker compose up.

What you need:

• PHP 8.2+ with Composer [README]
• MySQL or MariaDB [README]
• A web server (nginx configuration is included in the README) [README]
• Optional: Redis for background queue processing [README]
• A domain and SSL certificate (Let’s Encrypt works fine)
• SMTP if you want email-based notifications

The actual install steps:

1. Clone the repo, composer install
2. Create a MySQL database and user
3. Copy .env.example to .env, fill in database credentials and auth method
4. Run php artisan migrate and php artisan key:generate
5. Configure nginx to serve the public folder
6. Set up a queue worker (cron or daemon)
7. Configure authentication method

What can go wrong:

PHP server setup is a known pain point if you’ve never done it. Unlike Docker-compose tools, there’s no single file you download and run. You’re configuring nginx, PHP-FPM, and MySQL separately. For developers comfortable with Linux server administration, this is an afternoon of work. For a genuinely non-technical founder, this is a project that requires either a technical friend or a deployment service.

The README includes nginx config, and the Heroku deploy button makes that path simpler, but Heroku’s free tier is gone and the cheapest Heroku dyno starts at $7/month — erasing most of the cost advantage over Meetup.

There’s no Docker image in the official repository. Community-built Docker images may exist but aren’t officially supported or documented.

Realistic time estimate: 1–3 hours for a developer familiar with PHP hosting. Half a day to a full day for someone configuring PHP + nginx for the first time. “Heroku deploy” button path is the fastest for non-technical users, though it requires a paid Heroku account now [README].

The project’s maintenance posture: 163 stars, 12 forks, 527 commits, one primary maintainer. Aaron Parecki is an active developer and the project is genuinely in use (three live instances linked from the README). But this is one person’s project. There’s no company behind it, no issue bounty, no commercial support. If you hit a bug, you’re filing a GitHub issue and waiting, or fixing it yourself.

---

Pros and Cons

Pros

• MIT license, genuinely open source. No commercial tier, no features gated behind payment. Self-host and own it completely [README][1].
• IndieWeb-native. Webmention support means event pages can aggregate external posts, photos, and notes automatically from people’s own websites [README]. No other event tool does this.
• iCal feeds for everything. Every filtered view — home page, tags — has a subscribable iCal feed. Works with any calendar client [README].
• Multiple auth methods. GitHub, OIDC, passkey, Vouch — more flexibility than most small open-source projects bother to implement [README].
• Real production use. events.indieweb.org has been running since 2020. This isn’t vaporware [1][README].
• Intentionally minimal. The small scope means less to break, fewer dependencies to maintain, and a lower ongoing maintenance burden.
• Free. No per-event fees, no monthly organizer charges, no attendee data sold to advertisers.

Cons

• No Docker. Deployment requires PHP server knowledge. Not a one-command install [README].
• Single maintainer. 163 stars, no organizational backing. Long-term maintenance is a legitimate concern if Aaron Parecki moves on [README][1].
• No ticketing, no payments. If you need seat limits, waitlists, or paid events, you’re combining Meetable with a separate tool or building it yourself.
• No email reminders or notifications. Events don’t send attendees reminders before they happen. You configure email for system notifications, not for attendee engagement.
• No mobile apps. Web-only. Manageable for a listing site, but worth noting.
• No multi-tenancy. One Meetable install = one community’s events. If you want separate calendars for multiple organizations, you need multiple installs.
• Sparse documentation. The README covers installation, but there’s no user guide, no admin documentation, no FAQ for common configuration questions.
• Niche focus. The IndieWeb-centric design (webmentions, etc.) is a strength for that community and a feature you’ll never use if you’re not in it.

---

Who should use this / who shouldn’t

Use Meetable if:

• You run a developer community, standards group, or local tech meetup and want a permanent home for your events that doesn’t depend on Meetup.com’s pricing decisions.
• You care about IndieWeb principles — data ownership, webmentions, open formats.
• You or someone on your team can configure a PHP/nginx stack, or you’re willing to pay someone to deploy it once.
• You need a simple, archivable public events listing — not ticketing, not scheduling.

Skip it (use Luma instead) if:

• You need a polished registration experience with custom emails, branded pages, and attendee analytics.
• You’re not technical and don’t have a developer to handle deployment.
• Your events need ticket sales or paid tiers.
• You want a mobile app for event check-ins.

Skip it (use Mobilizon or Gancio instead) if:

• You want a federated events platform that integrates with the Fediverse (Mastodon, etc.) rather than IndieWeb-style webmentions.
• You need multi-tenancy from a single install.

Skip it (stay on Meetup.com) if:

• Discovery matters to you — Meetup.com has millions of users browsing for events. Self-hosted Meetable has zero built-in audience.
• You don’t have technical resources to maintain a server.

---

Alternatives worth considering

• Luma (lu.ma) — The current default for developer community events. Cleaner UI than Meetup, generous free tier, email workflows, ticketing. Closed-source SaaS with no self-hosted option.
• Meetup.com — The legacy option. Large audience for discovery, ongoing pricing concerns, no data export.
• Mobilizon — Federated events platform from Framasoft. Self-hosted, ActivityPub-native, better for Fediverse-connected communities. More complex than Meetable.
• Gancio — Another federated events tool, simpler than Mobilizon, also ActivityPub. Closer to Meetable in scope.
• Eventbrite — Only if you need ticketing. Feature-rich but expensive for organizers at scale.
• Cal.com — Different use case: individual scheduling (like Calendly), not community event listings. Frequently confused with event management tools by name.
• Indico — CERN’s open-source conference management system. Vastly more complex, aimed at academic conferences, not community meetups.

For a community organizer escaping Meetup.com, the realistic shortlist is Meetable vs Luma vs Mobilizon. Luma if you want a polished managed experience. Mobilizon if you want Fediverse federation. Meetable if you want IndieWeb standards, minimal scope, and complete data ownership on a server you control.

---

Bottom line

Meetable is honest about what it is: a minimal events listing website, not a platform. Aaron Parecki built it to solve a specific problem — the IndieWeb community needed a permanent, self-owned home for its events — and it does that job well [1]. The IndieWeb integration (webmentions, iCal feeds, decentralized RSVPs) is genuinely useful for communities that think about the web that way, and meaningless overhead for those that don’t.

The case for self-hosting it is real but narrow. If you’re running a recurring community events page, tired of Meetup.com’s pricing, and have the technical ability to configure a PHP server, Meetable saves you $200–250/year and gives you a permanent, archivable, open-format events history that you actually own. The risk is real too: 163 stars, one maintainer, no Docker, no commercial support. This is not the tool to bet your event operations on if you can’t maintain it yourself.

For non-technical founders specifically: the deployment path is a real barrier. Factor in a developer’s afternoon to deploy, or look at Luma’s free tier first. If the long-term data-ownership argument matters enough to you, Meetable is worth the deployment investment. If it doesn’t, Luma does the job without touching a server.

---

Sources

1. Aaron Parecki — “Meetable: An Open Source Events Aggregator” (January 14, 2020). https://aaronparecki.com/2020/01/14/13/meetable

Primary sources:

• GitHub repository and README: https://github.com/aaronpk/meetable (163 stars, MIT license, 527 commits)
• Live instance — IndieWeb Events: https://events.indieweb.org
• Live instance — OAuth.net Events: https://events.oauth.net
• Live instance — MCP Events: https://meet.modelcontextprotocol.io
• Official project website: https://meetable.org