MongooseIM

Enterprise messaging server, honestly reviewed. Built for serious scale — not for founders who just want to escape Slack.

TL;DR

• What it is: Open-source XMPP messaging server built in Erlang by Erlang Solutions, designed to power in-app messaging at enterprise scale [README][website].
• Who it’s for: Engineering teams building products with embedded real-time messaging — think customer support platforms, healthcare apps, fintech dashboards — who are paying $400–$2,000/mo to SendBird, Stream Chat, or CometChat and want to own the infrastructure [4][5].
• Cost savings: SendBird and Stream Chat start at ~$399/mo for 5,000 MAU and scale fast. MongooseIM self-hosted costs whatever your VPS costs — but only if your team can operate Erlang/OTP infrastructure.
• Key strength: Proven at extreme scale — a documented test hit 2.5 million concurrent connections at 45,000 messages per second, and the team says 10 million is achievable [3]. That’s not marketing: that’s a benchmark.
• Key weakness: This is not a turnkey app. MongooseIM is server infrastructure for developers. If you don’t have an Erlang or backend engineering capability, you’re not self-hosting this — you’re buying professional services from Erlang Solutions.

---

What is MongooseIM

MongooseIM is an XMPP messaging server written in Erlang/OTP, maintained by Erlang Solutions (a UK-based company with clients including Klarna, Visa, Mastercard’s Vocalink, and Danske Bank) [1][README]. It’s a fork and evolution of ejabberd, the original open-source XMPP server, hardened specifically for enterprise production use at scale.

The GitHub description is plain about the intended use: “MongooseIM is Erlang Solutions’ robust, scalable and efficient XMPP server, aimed at large installations. Specifically designed for enterprise purposes, it is fault-tolerant and can utilise the resources of multiple clustered machines” [README].

What this actually means in practice: MongooseIM is not a chat application you deploy for your team to use. It’s a messaging backend — a server that handles connections, routing, presence, and storage — that you build a chat product on top of. Your app’s mobile clients and web frontend connect to MongooseIM via XMPP, REST API, WebSockets, or BOSH (HTTP long-polling). MongooseIM handles the hard parts: connection state, message delivery, presence, and horizontal scaling across a cluster [README][website].

The project has 1,732 GitHub stars — modest by open-source standards, but that’s not the relevant metric here. The relevant metric is who runs it in production: the company’s client list includes Fortune 500 financial firms [1], and the case studies on the website name Beekeeper (employee communications) and Pando Health (healthcare messaging) [website]. These aren’t hobby deployments.

---

Why people choose it over SendBird, Stream Chat, and CometChat

The comparison that matters here isn’t Slack vs. self-hosted chat. It’s: you’re building a product that needs in-app messaging, and you’re evaluating whether to use a hosted messaging API or own the server yourself.

The hosted API pain. Platforms like SendBird and Stream Chat charge per Monthly Active User (MAU). At small scale this is fine — 100 users is cheap. At 50,000+ MAU you’re looking at $1,000–$5,000/mo. At a million MAU, you’re writing enterprise checks. AlternativeTo lists MongooseIM as a direct alternative to both Stream Chat [4] and SendBird [5], with exactly this audience in mind: “aimed at large, complex enterprise level projects, where real-time communication is critical for business success.” [4][5]

The Erlang advantage. Erlang was literally built by Ericsson to run telephone systems with 99.9999% uptime — the “nine nines” — and the BEAM virtual machine handles millions of lightweight concurrent processes natively. MongooseIM inherits all of this. The scalability test cited in the XMPP Newsletter [3] is striking: Bartek Górny from the MongooseIM team achieved 2.5 million simultaneous connections passing 45,000 messages per second on a documented setup, and assessed that 10 million connections was “easily achievable” [3]. This is the kind of number that makes a CTO running a social platform or a high-frequency messaging use case pay attention.

Data sovereignty. For healthcare (HIPAA), fintech (GDPR, PSD2), and government use cases, running your own messaging infrastructure isn’t optional — it’s compliance. MongooseIM runs in your own network, your own cloud account, your own data center. Erlang Solutions explicitly cites privacy compliance and government regulations as reasons clients choose this path [website].

The honest caveat. None of the third-party coverage [3][4][5] suggests that MongooseIM is easy. The AlternativeTo profile flags it as “aimed at large, complex enterprise level projects” [4] — that’s a polite way of saying this is not a weekend project. The Erlang Solutions website is also unusually transparent about their business model: they sell consulting, custom development, autoscaling tools, health checks, support contracts, and training on top of the open-source software [website]. The implication is that most production deployments involve professional services, not just docker-compose up.

---

Features

Based on the README and website documentation:

Core messaging:

• XMPP protocol support (the standard powering WhatsApp’s original backend, Google Talk, and most enterprise messaging [README])
• REST API for non-XMPP clients and server-to-server integration [README]
• WebSocket support for browser clients [README]
• BOSH (HTTP long-polling) for environments where WebSockets aren’t available [README]
• Server-Sent Events (SSE) [README]
• Message archiving and history [README]
• Presence and roster management [README]

Scalability and operations:

• Horizontal clustering — add nodes to expand capacity [README][website]
• MongooseIM Autoscaler: automatically adjusts cluster size to match user demand, reduces resources during off-peak periods [website]
• Metrics and monitoring integration [README]
• Load testing platform included in the platform components [README]
• CI/CD-tested releases on Ubuntu, Debian, CentOS/AlmaLinux/Rocky Linux [README]

Enterprise features (paid services, not software):

• 24/7 support contracts [website]
• Architecture and code review services [website]
• Health check service for existing deployments [website]
• Training for internal engineering teams [website]
• Custom feature development [website]

Deployment options:

• Docker image (official: erlangsolutions/mongooseim) [README]
• Helm chart on ArtifactHub [README]
• Pre-built packages for major Linux distributions [README]
• trymongoose.im demo environment [README]

What’s missing from the picture: The merged profile lists mobile_app and plugins as features, but there’s no detail in the available sources about first-party mobile SDKs or a plugin marketplace. Third-party XMPP client libraries are recommended rather than provided [README]. The license is listed as NOASSERTION in the profile data — the GitHub repo has historically used Apache 2.0, but this should be verified before production use.

---

Pricing: SaaS vs self-hosted math

MongooseIM software: Free (open-source). No per-seat, per-MAU, or per-message pricing on the software itself [README][website].

Erlang Solutions services: No public pricing. The website lists consulting, custom development, autoscaler, health checks, support, and training as separate service offerings with “Talk to us” calls to action [website]. Expect enterprise pricing.

Self-hosted infrastructure cost: Depends entirely on your scale:

• Small deployment (up to ~50K concurrent connections): $20–100/mo on a decent cloud VM or dedicated server
• Medium deployment (hundreds of thousands of concurrent): multi-node cluster, $200–800/mo
• Large deployment (millions of concurrent): significant infrastructure investment, but at that scale you’re already hemorrhaging money on SendBird

What you’d be replacing:

• SendBird: ~$399/mo for 5,000 MAU, scales to custom pricing past 100,000 MAU
• Stream Chat: similar pricing tier (~$399/mo base), per-MAU pricing above thresholds
• CometChat: similar structure

Concrete math for a mid-size product:

Say you’re running a platform with 100,000 MAU who use in-app messaging. On SendBird’s standard plans, you’re likely in the $2,000–$5,000/mo range. On a self-hosted MongooseIM cluster with two nodes on Hetzner, you’re spending $60–$150/mo on infrastructure. That’s $24K–$60K saved per year — if your engineering team can operate the cluster.

The “if” is the thing. Erlang Solutions doesn’t hide that most teams need help. Data not publicly available on what their support contracts cost, but the business model implies it’s priced for the enterprise clients who can afford it.

---

Deployment reality check

MongooseIM is an Erlang/OTP application. That’s the first and most important thing to understand before you try to self-host it.

What you need to run it:

• A Linux server (Ubuntu, Debian, or RHEL-compatible recommended) with at least 4GB RAM for a development instance, significantly more for production
• Docker for the containerized path, or compiled Erlang/OTP for bare-metal
• PostgreSQL or another supported database (MySQL, Cassandra, Riak are also supported per the documentation)
• A reverse proxy for TLS termination
• A network engineer who understands XMPP if you want federation
• Ideally, someone on your team who has run Erlang/OTP applications before

The Docker path is real. The official Docker image exists (erlangsolutions/mongooseim on Docker Hub) and the Helm chart is on ArtifactHub [README]. The trymongoose.im demo lets you poke at the server before committing. For developers comfortable with containers, getting a local instance running isn’t the hard part.

What actually goes sideways in production:

The XMPP Newsletter [3] documents a scalability test hitting 2.5 million connections, but doesn’t describe what the cluster setup looked like. Running at that scale is not a docker-compose up exercise — it requires understanding Erlang distribution, node communication, and the specific configuration knobs that MongooseIM exposes. The MongooseIM Autoscaler (their commercial tool for cluster management) exists precisely because managing cluster capacity is non-trivial [website].

Realistic time estimates:

• Development instance via Docker: 1–2 hours for an experienced backend developer
• Production cluster with monitoring, TLS, and a database: 2–5 days minimum for a team that hasn’t run XMPP infrastructure before
• Production cluster at scale with proper operations: weeks to months, depending on team’s Erlang familiarity

The honest assessment: For most non-technical founders, this tool is not self-hostable without a technical co-founder or hired backend engineer. For an engineering team building a product with messaging requirements, it’s a serious option worth evaluating. The company openly offers health checks specifically for teams who “reached the user limits of a less scalable solution” [website] — that’s a real use case.

---

Pros and Cons

Pros

• Proven at extreme scale. 2.5 million concurrent connections documented in a single test; designed for multi-million concurrent user deployments [3][README]. Few XMPP servers can match this.
• Erlang/OTP fault tolerance. The BEAM VM’s process isolation means one failing user session doesn’t crash others. Designed for 99.999% uptime workloads [1][README].
• Standard protocol (XMPP). Open standard means you can swap out client libraries, implement federation, and avoid vendor lock-in at the protocol level [3][README].
• Multiple transport options. XMPP, REST API, WebSockets, BOSH, SSE — you pick what fits your client stack [README][website].
• Active release cadence. Versions 6.3, 6.4, 6.5, and 6.6 released in sequence, with changelogs documenting substantive improvements (Prometheus integration, CockroachDB support, new integrations) [website].
• Docker and Helm deployment. Modern deployment tooling, not a 2010-era “compile from source” nightmare [README].
• Enterprise credentials. Erlang Solutions’ client list includes Klarna, Visa, Mastercard/Vocalink [1]. This matters when you’re betting your product’s messaging layer on it.

Cons

• Not for non-technical teams. This is infrastructure software. You need engineers to deploy, configure, and operate it. The company’s business model is built around selling services to teams who need help — which is honest, but means “free software” can become expensive quickly [website].
• Erlang/OTP is a niche skill. Finding engineers who can debug a production Erlang cluster is harder than finding Node or Go developers. This creates a long-term staffing risk.
• No public pricing for services. The software is free but the support contracts, autoscaler, and consulting that most production deployments seem to need have zero pricing transparency [website].
• 1,732 GitHub stars. The community is small. Compare this to Prosody (~1,500 stars) or ejabberd (~6,000+ stars) in the same XMPP space. If you hit an obscure edge case, Stack Overflow isn’t going to save you.
• No first-party UI. MongooseIM is a server. You build the client. That’s the right architectural decision, but it means more work before you have something a user can touch.
• License ambiguity in tooling. The data profile lists the license as NOASSERTION. Verify the actual license terms from the repository before production use.
• XMPP has a complexity reputation. The protocol is extensive, with hundreds of XEPs (XMPP Extension Protocols). You’ll implement a subset, but understanding which subset matters for your use case requires expertise.

---

Who Should Use This / Who Shouldn’t

Use MongooseIM if:

• You’re an engineering team building a product with in-app messaging that’s paying $1,000+/mo to SendBird, Stream Chat, or CometChat — and you have backend engineers who can operate a clustered server.
• You’re building in a regulated industry (healthcare, fintech, government) where your messaging data legally cannot leave your infrastructure.
• You expect tens of millions of concurrent connections — it’s one of the few OSS servers with credible benchmarks at that scale [3].
• You have existing Erlang/Elixir expertise on your team, or you’re already running Erlang Solutions’ stack for other infrastructure [1].
• You need XMPP federation — connecting to external XMPP domains or building interoperable messaging.

Skip it if:

• You’re a non-technical founder. This is not a “deploy and forget” tool. You’ll need technical help, and that help might cost as much as the SaaS you’re replacing.
• Your team has zero Erlang experience and doesn’t want to acquire it. The operational overhead is real.
• You need a chat application for your own team (internal comms). Use Mattermost or Rocket.Chat instead — they’re full applications with UIs.
• Your concurrent user count is under ~10,000. The complexity isn’t worth it at that scale; a hosted API is cheaper in total cost of ownership.
• You need a quick integration. MongooseIM’s REST API exists, but the primary integration path is XMPP — a protocol with a steeper implementation curve than a modern REST/WebSocket chat API.

---

Alternatives Worth Considering

• ejabberd — the XMPP server MongooseIM forked from. More community documentation, larger community (~6,000+ GitHub stars), lighter on enterprise features. A good choice if you don’t need MongooseIM’s scale ceiling and want more Stack Overflow coverage.
• Prosody — lighter-weight Lua-based XMPP server. Easier to operate for smaller deployments, but not designed for multi-million concurrent users.
• Matrix/Synapse — a modern federated messaging protocol with a growing ecosystem. Better for self-hosted team communication; less mature for embedded in-app messaging at the scale MongooseIM targets.
• Rocket.Chat — a full chat application with a UI, REST API, and mobile apps. The right pick if you want to replace Slack or Intercom, not build messaging infrastructure.
• Mattermost — similar positioning to Rocket.Chat: a Slack-replacement for teams, not messaging infrastructure for product developers.
• SendBird / Stream Chat (stay on SaaS) — if your engineering team can’t operate Erlang, the SaaS tax may be worth paying to avoid the operational complexity.
• Tinode — lighter-weight open-source instant messaging server (Go), easier to operate, lower scale ceiling. Worth considering for teams that want self-hosted messaging infrastructure without the Erlang prerequisite.

---

Bottom Line

MongooseIM is a technically serious piece of infrastructure that does exactly what it claims: handles messaging at scale that would make most servers buckle [3]. If you’re building a product where real-time messaging is core — healthcare, fintech, consumer social, support tooling — and you’re paying a growing monthly bill to SendBird or Stream Chat, the math for self-hosting eventually makes sense, and MongooseIM is one of the few open-source options with the scale credentials to take seriously.

The catch is that “eventually” requires an engineering team capable of running clustered Erlang in production. This is not a gap you bridge with a weekend and a DigitalOcean tutorial. Erlang Solutions knows this — their business model is built around selling the expertise to teams who need it. The software is free; the operations are not. If you have that team, or you’re willing to pay for their services while you build internal capability, MongooseIM is a legitimate alternative to SaaS messaging APIs at serious scale. If you don’t, it’s a tool to admire from a distance and pick up in two years when you’ve grown into it.

---

Sources

1. Erlang Solutions — FinTech and Blockchain Software Solutions (erlang-solutions.com). Lists enterprise clients and capabilities including Klarna, Vocalink (Mastercard), Visa. https://www.erlang-solutions.com/industries/fintech/
2. Shaynly — A Catalog of Self-Hosted Free Software (shaynly.com). Lists MongooseIM in the communication category of self-hosted software. https://shaynly.com/self-hosted-free-software/
3. XMPP Newsletter — “Monal update, eturnal and GSoC progress” (xmpp.org, August 6, 2020). Documents MongooseIM scalability test: 2.5 million connections at 45,000 messages/second. https://xmpp.org/2020/08/xmpp-newsletter-monal-update-eturnal-and-gsoc-progress-6-august-2020/
4. AlternativeTo — Stream Chat Alternatives (alternativeto.net). Lists MongooseIM as alternative with 13 likes, describes it as “aimed at large, complex enterprise level projects.” https://alternativeto.net/software/stream-chat/
5. AlternativeTo — SendBird Alternatives (alternativeto.net). Lists MongooseIM as alternative to SendBird in the same enterprise messaging context. https://alternativeto.net/software/sendbird/

Primary sources:

• GitHub repository and README: https://github.com/esl/mongooseim (1,732 stars)
• Official product page: https://www.erlang-solutions.com/products/mongooseim.html
• Documentation: https://esl.github.io/MongooseDocs/latest/
• Demo environment: https://trymongoose.im