# Errbot: a Python chatops daemon you extend with plugins

> Errbot connects to IRC, XMPP or Telegram out of the box and to Slack, Discord and Mattermost through add-on backends. Its real value is that plugins are plain Python classes, and the bot can install them from chat.

**errbotio/errbot** — Errbot is a chatbot, a daemon that connects to your favorite chat service and bring your tools and some fun into the conversation.

- Repository: https://github.com/errbotio/errbot
- Website: http://errbot.io
- Stars: 3,308 · Forks: 626
- Language: Python
- License: GPL-3.0
- Published: 2026-09-24 · Updated: 2026-09-24 · Language: en
- Canonical page: https://hysenlabs.com/projects/errbotio-errbot

## The problem Errbot solves: scripts that live where your team talks

Most internal tooling ends up as a shell script or a small service that somebody has to remember to run. Errbot's premise is that the chatroom is already the place where the request appears, so the bot should be the thing that runs the script. The README frames it as starting scripts interactively from your chatrooms, and lists the usual cases: chatops, starting a build, monitoring commits, triggering alerts.

The audience is narrower than "anyone who wants a bot". Errbot is a daemon, not a hosted service. It expects to be run somewhere with a persistent process, a data directory and a config.py, and it expects the person wiring it up to be comfortable in Python. If you want a bot that answers questions using a language model, this is not that project. If you want a bot that runs `deploy staging` because a colleague typed it in a channel, and you want the ACL for that command to be reviewable in a git repository, this is the shape you are looking for.

## How Errbot is put together: backends, plugins and a persisted store

Errbot splits into a core and a backend. The core handles the command loop, plugin loading, ACLs, persistence and the text console. The backend is the adapter to a chat network. The README marks IRC, Telegram and XMPP as built-in, and lists Slack, Discord, Gitter, Webex, Mattermost, RocketChat, Skype, TOX, VK and Zulip as add-ons with their own repositories. That split matters when you evaluate it: the core is one project, but the quality of your Slack or Mattermost experience is decided by a different package with a different maintainer.

Plugins are Python classes loaded from a plugins directory. The README notes that `errbot --init` drops an `err-example` plugin there for you to read. State is handled through a dict-like interface: the README gives `self['foo'] = 'bar'` as the way to persist a value, and separately mentions an integrated `!backup` command that exports persisted data. Command metadata comes from docstrings, so help text is generated rather than written twice. There is also a webhook callback path and a polling facility for plugins that need to act on a schedule.

The dependency list in pyproject.toml is worth reading before you install. It pins exact versions, including flask, requests, jinja2, pyOpenSSL, dulwich and markdown, and requires Python 3.10 or newer. Exact pins make reproducible installs easier and make it harder to pick up a security fix in a transitive dependency without a release from this project.

## Installing Errbot and talking to it in text mode

The README recommends a virtualenv, then four steps: install from pip, create a data directory, initialize it, and run the bot in text mode. The commands below are the ones the README gives, with the directory named `errbot` as in its example.

```bash
$ pip install errbot
$ mkdir errbot; cd errbot
$ errbot --init
$ errbot
```

After the last command you get a `>>>` prompt and can talk to the bot without connecting to any chat network. The README suggests `!help` as the first thing to try. This text mode is also available later regardless of your configured backend: the README notes that `errbot -T` still works for local testing even after you change BACKEND in the configuration.

To add a built-in chat system, install the matching extra. For IRC the README gives this form:

```bash
$ pip install "errbot[irc]"
```

The extras declared in pyproject.toml are `slack`, `discord`, `mattermost`, `IRC`, `telegram` and `XMPP`, plus a `test` extra that pulls in pytest and requests. Note the capitalisation: the extra is `IRC`, not `irc`, in the packaging metadata, even though the README's example uses lowercase and quotes it. Install the extra before or after the base package; the README says adding it later is fine.

Configuration lives in the `config.py` that `errbot --init` generates. The README points to a documented template, `config-template.py`, on the master branch of the repository, rather than reproducing the keys inline. Once the bot connects, administration happens in a one-on-one chat with a handle listed in BOT_ADMINS. Plugin management from chat looks like this:

```bash
!repos search jira
!repos install errbotio/err-imagebot
```

The first searches the public plugin repositories, the second installs one by its repository name. The README also lists install, uninstall, update, enable and disable as chatops operations, and says plugins can be configured from chat as well.

To run detached, the README gives the daemon flag:

```bash
errbot --daemon
```

## Where Errbot gets awkward

The backend split is the first real cost. Built-in support covers IRC, Telegram and XMPP. Everything else, including Slack, Discord, Mattermost, RocketChat and Zulip, is a separate repository with its own release cadence. The README links to those repositories for instructions rather than describing them. That means a version bump in the core can leave you waiting on a backend maintainer, and the backend's documentation is not in this repository.

The pinned dependencies are a second constraint. pyproject.toml pins flask, requests, jinja2, pyOpenSSL, dulwich and others to exact versions. If your environment already has a different version of one of those, you are resolving a conflict rather than just installing a bot. The `setuptools>=78.1.1` entry in the runtime dependencies is also unusual enough to notice: setuptools is a build tool, and having it installed at runtime is a decision you inherit.

Python version support is 3.10 and above, per both the README and the classifiers. The XMPP extra in pyproject.toml branches on the interpreter version, pulling slixmpp 1.12.0 below Python 3.11 and 1.15.0 at or above it. That is a sign of active care for the XMPP path, but it also means an XMPP install is not reproducible across Python versions without pinning the interpreter too.

Finally, the README does not document rollback. `!repos install` and `!repos update` are described as chat commands, and `!backup` is described as producing a full export of persisted data, but nothing in the README explains how to revert a plugin to a previous revision or what happens to persisted state when a plugin is uninstalled. If plugin state matters to you, treat that as an open question to answer from the source, not from the README.

## Errbot against Opsdroid, and against writing your own bot

Opsdroid is the closest comparison people search for alongside Errbot, and the difference is in where the extension logic lives. Errbot plugins are Python classes loaded by the core, with state accessed through the bot's own storage interface and help generated from docstrings. Opsdroid's model is built around connectors and skills configured through a YAML file, with skills as modules that declare matched functions. If your team is more comfortable editing YAML than subclassing, Opsdroid's configuration surface is smaller. If you want the bot's behavior to be ordinary Python that you can unit test, import and refactor, Errbot's plugin model is the more direct fit.

The other alternative is a small custom service: a webhook receiver plus a chat SDK. That gives you total control and no plugin lifecycle to learn. It also means you write the ACL layer, the persistence, the help generation and the plugin install path yourself. Errbot's pitch is that those are already there. Whether that trade is worth it depends on how many commands you expect to have. For one or two commands, a custom service is less machinery. For a dozen commands owned by different people, a plugin directory with per-command ACLs is easier to review.

## Licence, maintenance and what an upgrade actually costs

Errbot is GPL-3.0-or-later, per pyproject.toml, which also lists COPYING as the licence file. The repository contains a `gplv3-exceptions.txt` file, which suggests the project has carved out specific exceptions to the GPL for some components; if you plan to redistribute Errbot inside a product, read that file and the COPYING text rather than assuming the licence is uniform across everything in the tree. This is not legal advice, and the exception file is the thing to bring to whoever handles licensing on your side.

The last push to the default branch was on 2026-08-17, and release 6.2.1 was tagged the same day. The previous release, 6.2.0, was tagged on 2024-01-04, and 6.1.9 on 2022-06-11. The pattern is long gaps between releases with a maintenance release at the end of the most recent one. There is no archived flag on the repository, so it has not been formally retired, but the release history is the honest signal: plan for infrequent releases rather than a steady stream.

Upgrade cost is dominated by the exact pins. Moving from one Errbot version to the next can move flask, requests, jinja2, pyOpenSSL and dulwich at the same time. If you run Errbot in a virtualenv of its own, that is contained. If you install it into an environment shared with other services, budget time for dependency resolution on every bump. The Dockerfile in the repository installs into a python:3.12-slim image as a non-root `errbot` user, runs `errbot --init` at build time, exposes ports 3141 and 3142, declares /home/errbot as a volume and sends SIGINT as the stop signal. Building your own image along those lines keeps the dependency churn inside the container.

## Conclusion

Adopt Errbot if your team already lives in IRC, XMPP or Telegram and you want command logic in Python rather than in a proprietary bot builder. Skip it if you need Slack-first behavior, because that path depends on the separate errbot-backend-slackv3 package rather than the core. Before committing, run errbot --init in a scratch directory and read the generated config.py against the config-template.py in the repository, since the README does not document which keys each backend requires.

## FAQ

### What is Errbot in Python?

Errbot is a chatbot daemon written in Python that connects to a chat service and lets you start scripts from a chatroom. It is extended with plugins written as Python classes, and it requires Python 3.10 or newer.

### How do I install Errbot?

The README recommends a virtualenv, then `pip install errbot`, followed by creating a data directory, running `errbot --init` and starting `errbot`. Built-in chat backends are added with extras such as `pip install "errbot[irc]"`.

### Does Errbot support Slack and Mattermost?

Not in the core. The README lists Slack, Discord, Gitter, Webex, Mattermost, RocketChat, Skype, TOX, VK and Zulip as add-ons with their own repositories, while IRC, Telegram and XMPP are built in. pyproject.toml also declares slack, discord and mattermost extras that pull the corresponding backend packages.

### How do I install Errbot plugins?

A bot admin can search the public plugin repositories with `!repos search` and install one with `!repos install`, for example `!repos install errbotio/err-imagebot`. The README also lists uninstall, update, enable and disable as operations available from chat.

### What does "bot" mean in a chat conversation?

Errbot's documentation does not define the general term; it describes its own bot as a daemon that connects to a chat service and brings your tools into the conversation, reachable by sending it commands such as `!help`.

## Sources

- [errbotio/errbot on GitHub](https://github.com/errbotio/errbot)
- [License: GPL-3.0](https://github.com/errbotio/errbot/blob/master/LICENSE)
- [Project website](http://errbot.io)
- [README](https://github.com/errbotio/errbot/blob/master/README.md)
- [Releases](https://github.com/errbotio/errbot/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/errbotio-errbot