Opencom vs Chatwoot vs Papercups: Self-Hosted Chat 2026

Intercom is powerful, expensive, and the definition of vendor lock-in. The open-source live chat space has matured considerably, with three distinct options now occupying different niches: Chatwoot for full-featured omnichannel support, Papercups for lightweight developer-first chat, and Opencom as the newest entrant aiming to replicate the full Intercom product experience.

This comparison cuts through the noise and tells you which to deploy. Note: if you already have a Chatwoot setup and want a migration path, see our existing Chatwoot self-hosting guide and the Intercom to Chatwoot migration guide. This article focuses on the three-way comparison and what each tool does uniquely well — particularly where Papercups and Opencom fit when Chatwoot is not the answer.

The Three Contenders

Chatwoot

Chatwoot is the dominant open-source Intercom/Zendesk alternative with over 22,000 GitHub stars. Built on Ruby on Rails (backend) and Vue.js (frontend), it handles omnichannel customer support: website live chat, email, WhatsApp, Facebook, Instagram, Telegram, Twitter/X, and more — all in a unified inbox. Chatwoot has a mature product, active development team, and a growing AI feature set (an AI assistant called Captain).

Chatwoot has been around since 2019, has regular releases, and is widely deployed in production. It is the safe, full-featured choice.

Papercups

Papercups is the opposite philosophy. Built in Elixir and Phoenix (the backend), with a React frontend, Papercups prioritizes simplicity, developer ergonomics, and low operational overhead. It launched in 2020 as a YC S20 company with the explicit goal of being a minimal, embeddable live chat widget that developers could actually understand and maintain.

The trade-off: Papercups entered maintenance mode as of 2025. It receives security updates but no new features. The project succeeded in proving the concept but the company pivoted. If you deploy Papercups today, you are deploying a stable but frozen tool.

Opencom

Opencom is the newest of the three and the most ambitious in scope. It is a fully open-source customer engagement platform under AGPLv3, aiming to replicate the entire Intercom product surface: live chat, product tours, onboarding checklists, campaigns, surveys, ticketing, and AI agent responses — all in one platform.

The tech stack is modern: Next.js and React for the dashboard, Expo for a native iOS/Android admin app, and Convex as the serverless backend. As of early 2026, Opencom has around 20 GitHub stars and is in early active development. It is not yet production-ready for high-traffic deployments, but it is actively maintained and represents the most feature-complete open-source Intercom clone available.

Feature Comparison

Feature	Chatwoot	Papercups	Opencom
Live chat widget	✅	✅	✅
Email channel	✅	✅	✅
WhatsApp	✅	❌	❌
Facebook/Instagram	✅	❌	❌
Twitter/X	✅	❌	❌
Telegram	✅	❌	❌
Product tours	❌	❌	✅
Onboarding checklists	❌	❌	✅
In-app campaigns	❌	❌	✅
Surveys / NPS	❌	❌	✅
Native mobile admin app	iOS/Android	❌	iOS/Android (Expo)
AI assistant	✅ (Captain)	❌	✅
Canned responses	✅	❌	✅
Automation rules	✅	❌	✅
Help center / KB	✅	❌	✅
Slack integration	✅	✅	Planned
GraphQL API	❌	✅	✅ (Convex)
Active development	✅	Maintenance only	✅ (early)
GitHub stars	22,000+	3,000+	~20
License	MIT	MIT	AGPLv3

Self-Hosting Deep Dive

Chatwoot: Docker Compose

Chatwoot's self-hosted deployment uses Docker Compose with PostgreSQL and Redis. The stack is well-documented and battle-tested.

# Download the official setup script
curl -o /tmp/setup.sh https://raw.githubusercontent.com/chatwoot/chatwoot/develop/deployment/setup_20.04.sh

# Or use Docker Compose directly
git clone https://github.com/chatwoot/chatwoot.git
cd chatwoot
cp .env.example .env

Minimal docker-compose.yml for Chatwoot:

version: "3"

services:
  base:
    &base
    image: chatwoot/chatwoot:latest
    env_file: .env
    volumes:
      - /data/storage:/app/storage

  rails:
    <<: *base
    depends_on:
      - postgres
      - redis
    ports:
      - "3000:3000"
    command: bundle exec rails s -p 3000 -b 0.0.0.0

  sidekiq:
    <<: *base
    depends_on:
      - postgres
      - redis
    command: bundle exec sidekiq -C config/sidekiq.yml

  postgres:
    image: postgres:14
    restart: always
    environment:
      POSTGRES_USER: chatwoot
      POSTGRES_PASSWORD: your_password
      POSTGRES_DB: chatwoot_production
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:alpine
    restart: always
    volumes:
      - redis_data:/data

volumes:
  postgres_data:
  redis_data:

Resource needs: 4 GB RAM minimum, 8 GB recommended. The Rails + Sidekiq combination is memory-hungry. Chatwoot also runs background jobs via Sidekiq, which means you need Redis in addition to PostgreSQL.

After setup, run database migrations:

docker compose run --rm rails bundle exec rails db:chatwoot_prepare

Papercups: Docker Compose

Papercups is significantly lighter. It is an Elixir/Phoenix application with PostgreSQL — no Redis, no separate job worker. The Erlang VM (BEAM) handles concurrency and background work natively, which is part of why Papercups can run on much smaller infrastructure.

version: "3"

services:
  app:
    image: papercups/papercups:latest
    depends_on:
      - db
    environment:
      DATABASE_URL: postgresql://papercups:your_password@db/papercups_dev
      SECRET_KEY_BASE: your_secret_key_base_here
      BACKEND_URL: https://chat.yourdomain.com
      MIX_ENV: prod
    ports:
      - "4000:4000"
    command: sh -c "sleep 3 && /app/entrypoint.sh"

  db:
    image: postgres:13
    environment:
      POSTGRES_USER: papercups
      POSTGRES_PASSWORD: your_password
      POSTGRES_DB: papercups_dev
    volumes:
      - db_data:/var/lib/postgresql/data

volumes:
  db_data:

Resource needs: 512 MB RAM minimum, 1 GB comfortable. Elixir's BEAM VM is extraordinarily efficient for concurrent connections. A single Papercups instance can handle thousands of simultaneous chat sessions on hardware that would struggle with Chatwoot.

Generate a SECRET_KEY_BASE:

openssl rand -hex 64

After deployment, the embed snippet for your website:

<script>
  window.Papercups = {
    config: {
      token: "your-account-token",
      inbox: "your-inbox-id",
      title: "Welcome!",
      subtitle: "Ask us anything",
      primaryColor: "#1890ff",
    },
  };
</script>
<script
  type="text/javascript"
  async
  defer
  src="https://chat.yourdomain.com/widget.js"
></script>

Opencom: Setup

Opencom's architecture is different from both Chatwoot and Papercups. Its backend is Convex — a serverless database and compute platform. This means the self-hosting model is less traditional container-based and more framework-specific.

# Prerequisites: Node.js 18+, PNPM 9+
git clone https://github.com/opencom-org/opencom.git
cd opencom

# Install dependencies
pnpm install

# Run the setup script (handles Convex config, workspace setup)
./scripts/setup.sh

For a self-hosted backend with the hosted dashboard (the easiest path):

1. Create a Convex account at convex.dev (free tier available)
2. Run pnpm convex deploy from the repo root
3. Use the hosted dashboard at app.opencom.dev pointing to your Convex backend

For fully self-hosted, you can run Convex locally or use an open-source Convex alternative. The setup script walks through prerequisites checking, dependency installation, Convex project creation, and workspace initialization.

Resource needs: Depends on Convex. If using the hosted Convex free tier, your own infrastructure only serves the frontend. For a fully self-hosted setup, requirements scale with your usage.

The embed widget for websites:

<script>
  (function(o,p,e,n,c,o2,m){
    o[c]=o[c]||function(){(o[c].q=o[c].q||[]).push(arguments)};
    var s=p.createElement(e);s.async=1;s.src=n;
    p.getElementsByTagName(e)[0].parentNode.insertBefore(s,p.getElementsByTagName(e)[0]);
  })(window,document,'script','https://your-opencom-instance/widget.js','opencom');
  opencom('init', { appId: 'your-app-id' });
</script>

Channels and Integrations

Chatwoot is the clear winner for channel breadth. If your customers reach you via WhatsApp, Instagram DMs, Twitter mentions, or Telegram — and you want all of that in a single inbox — Chatwoot is the only option of the three that supports this out of the box.

Papercups focuses on what it does well: website chat, email, and Slack. The Slack integration is genuinely useful for small teams — conversations from your website chat show up in a Slack channel, and your team responds from Slack. This makes Papercups zero-training for teams already living in Slack.

Opencom currently lacks the social channel integrations of Chatwoot but compensates with product engagement features no other self-hosted tool offers. Product tours, onboarding checklists, and behavioral campaigns — the features that make Intercom worth $100+/month for SaaS companies — are in Opencom's roadmap and partially implemented already.

Agent Features and Workflows

Chatwoot has the most mature agent workflow tooling: canned responses, automation rules (route conversations by keyword, assign by team, escalate after time), labels, CSAT surveys, and a built-in knowledge base / help center. The AI assistant (Captain) can draft responses, summarize conversations, and auto-respond to common queries.

Papercups is bare-bones here. There is conversation assignment, closing, and prioritization. No automation rules, no canned responses, no AI features. This is by design — Papercups positions itself as the primitive that developers build on top of, using its REST and GraphQL APIs.

Opencom includes automation rules, canned responses, and AI agent responses out of the box. Its audience segmentation allows routing conversations or triggering campaigns based on user attributes — something neither Chatwoot nor Papercups handles in the same way.

Migration and Embed Code

Migrating from Intercom to Chatwoot

Replace your Intercom snippet with the Chatwoot widget:

// Remove Intercom snippet, add:
window.chatwootSettings = {
  hideMessageBubble: false,
  position: "right",
  locale: "en",
  type: "standard",
};
(function(d,t) {
  var BASE_URL="https://support.yourdomain.com";
  var g=d.createElement(t),s=d.getElementsByTagName(t)[0];
  g.src=BASE_URL+"/packs/js/sdk.js";
  g.defer = true;
  g.async = true;
  s.parentNode.insertBefore(g,s);
  g.onload=function(){
    window.chatwootSDK.run({
      websiteToken: "your-website-token",
      baseUrl: BASE_URL
    })
  }
})(document,"script");

Migrating from Intercom to Papercups

Papercups' widget is deliberately similar to Intercom's in API shape:

// Remove window.intercomSettings and Intercom() calls
// Add Papercups widget instead
window.Papercups = {
  config: {
    token: "your-token",
    inbox: "your-inbox",
    primaryColor: "#your-brand-color",
  },
};

The Papercups.identify() call maps to Intercom's Intercom("update", { user_id: ... }):

// Intercom
Intercom("update", { user_id: "123", email: "user@example.com" });

// Papercups equivalent
window.Papercups.identify({ external_id: "123", email: "user@example.com" });

Resource Usage in Practice

The resource differences between these three tools are significant enough to affect your infrastructure decisions:

	Chatwoot	Papercups	Opencom
Min RAM	4 GB	512 MB	~1 GB (varies)
Database	PostgreSQL + Redis	PostgreSQL only	Convex (serverless)
Concurrent chats	Hundreds (per instance)	Thousands (BEAM)	Depends on Convex tier
Startup time	~30–60 seconds	~5 seconds	Near-instant (serverless)
Scaling	Horizontal (multiple instances)	Horizontal (BEAM clustering)	Convex auto-scales

Papercups' use of Elixir is a genuine technical advantage for chat workloads. The BEAM VM was designed for exactly this use case — massive concurrency, soft real-time requirements, fault tolerance. A single Papercups server can handle a conversation load that would require multiple Chatwoot instances with a load balancer.

Which Should You Deploy?

Deploy Chatwoot if:

• You need WhatsApp, Instagram, Facebook, Telegram, or Twitter channels
• You have multiple support agents with role-based access
• You want AI-assisted response drafting and automation rules
• You need a knowledge base / help center paired with live chat
• Your team is non-technical and needs a polished UI that works out of the box
• Resources: you have a 4 GB+ VPS available

Deploy Papercups if:

• You need a lightweight, embeddable chat widget with minimal overhead
• Your stack is developer-first and your team uses Slack as primary communication
• You need GraphQL API access to build custom integrations
• You are happy running on a 1 GB VPS and want minimal operational overhead
• You accept that no new features will be added (maintenance mode)
• Resources: you want the smallest possible footprint

Deploy Opencom if:

• You are building a SaaS product and need Intercom-style product tours, onboarding checklists, and behavioral campaigns
• You want the fullest Intercom feature parity in an open-source tool
• You are comfortable adopting early-stage software and contributing to its development
• WhatsApp/social channels are not a current requirement
• Resources: you are comfortable with Convex's serverless model

For most teams coming from Intercom or Zendesk who want a drop-in replacement, Chatwoot remains the most practical choice — its maturity, community, and omnichannel breadth are hard to beat. See also our comparison of open source alternatives to Intercom for a broader view of the space, including tools like Zammad and Rocket.Chat.

The Opencom Wildcard

It is worth saying clearly: Opencom is genuinely interesting and potentially the most ambitious open-source Intercom clone ever built. With 19+ features covering the full Intercom product surface — tours, campaigns, surveys, checklists, AI agents — it targets the exact pain that causes teams to pay Intercom's enterprise pricing.

However, with ~20 GitHub stars and an early-2026 state of development, deploying Opencom for production customer support today carries real risk. The project could mature into the definitive Intercom alternative, or it could stall. If you are evaluating Opencom, join the GitHub repository, contribute feedback, and consider the hosted version at app.opencom.dev before committing to self-hosting.

Summary

Three very different tools, three very different use cases:

• Chatwoot (22k stars, Rails+Vue, 4 GB RAM): The safe, full-featured, production-proven choice for omnichannel support
• Papercups (3k stars, Elixir/Phoenix, 512 MB RAM): The lightweight developer tool — frozen in maintenance mode but technically excellent
• Opencom (~20 stars, Next.js+Convex, early stage): The most complete Intercom clone, worth watching as it matures

Pick the tool that matches your current requirements, not aspirational ones. If you need WhatsApp today, that decision is made. If you need product tours, Opencom is your only self-hosted option.