Open Source Zendesk Alternatives

Chatwoot centralizes customer conversations into one inbox no matter where they arrive, covering website live chat, email, Facebook, Instagram, Twitter, WhatsApp, Telegram, Line and SMS. Support teams stop switching between a dozen consoles, and because the platform is self-hosted, the customer data stays under the company's own control.

Captain, the built-in AI agent, automates responses and handles common queries so routine questions resolve without an agent reading them, leaving the team on conversations that need judgment. A help center portal publishes articles, FAQs and guides, which trims the repetitive questions that reach the inbox in the first place.

The daily work of a support team is covered by a wide feature set.

• Collaboration: private notes, mentions, labels, canned responses, keyboard shortcuts and a command bar.
• Routing: auto-assignment by agent availability, teams, business hours, auto-responders and capacity management.
• Customer data: contact profiles with interaction history, segments, custom attributes, pre-chat forms and outbound campaigns.
• Integrations: Slack, Dialogflow, Shopify, Linear, Google Translate and dashboard apps embedded in the interface.
• Reporting: a live view of ongoing conversations plus conversation, agent, inbox, label, team and CSAT reports, downloadable for offline analysis.

Deployment includes a one-click Heroku button and a DigitalOcean Kubernetes app, with further options in the documentation, though environment variables need setting carefully or features break. Development follows a git flow model on the develop branch, so anyone wanting stability should track master or a tagged release.

Zammad is an open source helpdesk and customer support platform for teams juggling inquiries across several channels at once. Email, chat, telephone and social media conversations land in one place, so a support team works from a shared view instead of separate inboxes and a private memory of who answered what.

Ownership is unusual for a project of this size. The source code belongs to the Zammad Foundation, independent of commercial providers, while development is carried out by Zammad GmbH together with the community. The software is licensed under the GNU AGPLv3 and the project states it will stay open source.

Installation is offered in several shapes.

• Docker images: official container images and a Docker Compose setup are published.
• Helm chart: a chart is available for Kubernetes clusters.
• Binary packages: DEB and RPM builds track both the stable and the develop branch.
• REST API: documented endpoints let other systems read and write tickets.
• Documentation: an installation guide, a developer manual and a security policy ship with the project.

For teams that would rather skip setup, configuration, backup and update work, Zammad GmbH runs a cloud service with a free trial instance. Hosting it yourself keeps customer conversations on your own servers, which is usually the reason to pick it in the first place.

erxes describes itself as an experience operating system, one self-hosted place to run marketing, sales, operations and support instead of paying separate subscriptions for each. The project positions itself against HubSpot, Zendesk, Linear and Wix.

The codebase is an Nx monorepo. Backend services speak GraphQL Federation and tRPC over Node.js, TypeScript, MongoDB, Redis and BullMQ, while the interface is assembled from React micro-frontends built with Rspack and Tailwind CSS through Module Federation.

A core carries inbox, contacts, products, segments, automation and documents, and a marketplace of plugins layers business capability on top.

• Frontline: omnichannel conversations, tickets and tasks for customer-facing teams.
• Operation: projects, team resources and cycle management in a single workspace.
• Sales: landing pages, forms, pop-ups and embeds that capture visitors as qualified leads.
• Content: headless websites, e-commerce, scheduling, knowledge base and help center publishing.
• Vertical plugins: accounting, finance, tourism, property and team modules for specific industries.

Generating a new plugin scaffolds both the backend schema and the Module Federation frontend remote, so extending the platform follows one path rather than several. Running it needs Node.js 18 or newer, pnpm 8 or above, MongoDB and Redis, with an API gateway fronting the core and every plugin API. Docker Compose gets an instance up quickly for anyone evaluating it.

Running support on Zendesk or Help Scout leaves your customer conversations on somebody else's server, with a bill that grows alongside the team. FreeScout answers both problems, a free help desk and shared inbox built on Laravel, written from scratch and hosted wherever you like.

Everything arrives in one inbox. Email flows in over SMTP, IMAP or POP3, with modern OAuth authentication for Microsoft Office 365 and Google Workspace, while WhatsApp, Telegram, Facebook, Slack and live chat feed the same queue.

Day-to-day work is shaped by a handful of behaviors.

• Unlimited everything: agents, tickets and mailboxes are never counted against a license.
• Collision detection: a notice appears when two agents open the same conversation.
• Conversation handling: forwarding, merging, moving, starring, internal notes and auto replies are built in.
• Accessibility: the interface fully supports screen readers and works on mobile.
• Translations: close to thirty languages ship with the application.

Requirements stay modest, Nginx, Apache or IIS, PHP 7.4 through 8.x, and MySQL, MariaDB or PostgreSQL, with no stated processor or memory floor, so shared hosting is a realistic target. A web installer and updater handles setup and upgrades, and one-click installs exist for Docker, Cloudron, Softaculous and several managed hosts. Mobile apps mirror the web version, installed modules included.

Frappe Helpdesk grew out of frustration with the ERPNext support module, whose interface and usability the Frappe team found hard to live with. What they built instead is a ticket management tool with a clean interface, easy setup and enough automation to keep customer queries from piling up.

It sits on the Frappe Framework, a full-stack web framework written in Python and JavaScript, with the interface assembled from the Vue-based Frappe UI library. That makes it a natural fit for anyone already running Frappe or ERPNext, and customizable in the same way as the rest of that ecosystem.

The support workflow rests on a few pieces.

• Dual portals: agents and customers each get their own view, keeping submission and management separate.
• Customizable SLAs: response targets are set and tracked so nothing quietly ages out.
• Assignment rules: tickets route automatically by priority, issue type or agent workload.
• Knowledge base: help articles are published for customers, with search surfacing the relevant ones.
• Saved replies: prewritten responses keep common answers quick and consistent.

Production setup is a single install script that provisions a working instance in roughly five minutes, and a Docker Compose file plus the local bench workflow are documented for development. Frappe Cloud offers managed hosting, including upgrades and monitoring, for teams that would rather not operate the stack themselves.

Chaskiq puts the front line of customer service into software you run yourself: a web messenger on your site, agents answering it, campaigns going out and a help center sitting behind both. The project describes itself as source available rather than fully open, a distinction worth understanding before building on it.

A Rails backend serves a GraphQL API with OAuth authorization, consumed by a React frontend. PostgreSQL holds the records and Redis handles caching and transient data, so the operational shape is familiar to anyone who has run a Rails application before.

The platform reaches well past a chat widget.

• Web messenger: an embeddable chat with a rich text editor, animated GIFs, embedded video, syntax-highlighted code and video calls over WebRTC.
• Segments and routing: customers are filtered by custom attributes and conversations routed to the right agent.
• Automation: triggerable conversational bots, onboarding tours and mailing campaigns run without an agent present.
• Help center: a multilingual article system that lives on a custom domain or inside the messenger itself.
• Integrations: WhatsApp, Twitter DM, Slack, Calendly, Zoom, Pipedrive and webhooks connect it to the rest of your stack.
• Governance: configurable GDPR consent, audits on access and record changes, and a composable roles and permissions system.

Development guides exist for macOS, Ubuntu, Windows and Docker, needing Ruby 2.6 or newer, PostgreSQL 10 or newer and Redis 2.6 or newer. A commercial license lifts the AGPL and commons clause terms for proprietary use.

Cossistant ships a support chat widget as React components you compose, rather than a script tag that injects someone else's interface into your page. The approach is code-first and API-driven, with headless hooks and primitives, real-time messaging, and the backend to run all of it, documented for developers and the AI tools they use.

Two packages carry the client side. The React SDK provides the headless hooks and primitives, and a companion package adds Next.js bindings and utilities. Behind them sits a Turborepo monorepo running on Bun, with Hono and tRPC for the API, Drizzle ORM for the database, Better Auth for sessions, WebSockets for live messages, and Docker running Postgres and Redis locally.

The split between widget and infrastructure shapes what you actually get.

• Headless components: styling and layout stay yours, because the SDK ships behavior rather than a fixed look.
• Real-time messaging: conversations travel over WebSockets instead of polling an endpoint.
• Full backend: the API, database and auth are part of the project, not a hosted dependency you rent.
• Next.js package: a separate module covers the framework-specific bindings and utilities.
• Documentation: a quickstart for adding it to an app and a contributors guide.

The project is licensed AGPL-3.0 for non-commercial use, and commercial deployments need a license from the maintainers. It is part of the Vercel open source program and runs a program of its own for other open source projects. It suits a team that wants support chat in their product without handing the conversation to a third party.

Written in Node.js and Express, Tiledesk is a live chat platform with chatbots built in, for teams running their own customer support instead of renting a widget. Conversations can be automated with its native chatbot technology, connected to other systems through APIs and webhooks, and given entire visual applications to run inside the chat itself.

Its multichannel model removes the duplicated work of maintaining one bot per channel. Chatbot scripts are written once with images, buttons and whatever elements a channel supports, and replies auto-adapt to wherever they land. This repository is the dashboard, an Angular back office, while the chat components come from the Chat21 project.

The back office covers the day-to-day of a support desk.

• Conversations: unlimited chats with labels, notes, canned responses and full history.
• Routing: departments and agent groups direct conversations, with operating hours respected.
• Ticketing: a ticketing system sits beside live chat for anything that outlives a session.
• Widget: the web widget is customizable, with iOS and Android apps available as separate components.
• Reporting: data export, analytics and a built-in CRM track what the desk is handling.

The quickest install is the published Docker Compose setup, which brings up every component at once. From source you need Node, the Angular CLI and a running Tiledesk server, with settings held in environment files or a remote dashboard config. The dashboard is MIT licensed, and the cloud service offers the same modules under the same license.