Self-hosted service
alerta/alerta avatar
alerta/alerta

Alerta: a self-hosted alert aggregation API for teams drowning in monitoring tools

Alerta monitoring system

2,535 stars380 forksPythonApache-2.0

At a glance

What is it?
Alerta collects alerts from any source into one API and one dashboard. This review covers how the server, database and web console fit together, how to run it with Docker Compose, and where the project's own documentation stops short.
Who is it for?
Adopt Alerta if you already run several monitoring systems and want one API and one console in front of them, and you are willing to operate MongoDB or PostgreSQL yourself. Do not adopt it if you expect a turnkey SaaS replacement with built-in check scheduling; Alerta receives alerts, it does not generate them.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 36 days ago.
What is it written in?
Mainly Python, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 19, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • alerta/alerta2,535 ★ · +6
Star history
Repository2026-09-302026-11-19
alerta/alerta2.5k2.5k

6 Stars in the last 50 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

What Alerta actually solves, and for whom

Most monitoring stacks end up with the same shape: Nagios or Prometheus or a cloud provider's alerting fires into an email inbox, and a human sorts through it. Alerta sits in that gap. It is an alert aggregation server, not a monitoring system. It does not poll your hosts, run checks or decide that a disk is full. Something else decides that, and then posts the alert to Alerta's API.

The README states the project's aims plainly: distributed and de-coupled so that it is scalable, minimal configuration so that it easily accepts alerts from any source, and quick at-a-glance visualisation with drill-down to detail. Those three aims describe the intended user well. It is for an operations team that already has alert sources and wants one place to see them, acknowledge them, and correlate them.

The decoupling is the design decision worth noticing. Because the server only receives alerts, adding a new source means writing or configuring a sender, not extending Alerta itself. The repository ships examples under examples/backends/, examples/plugins/ and an examples/oembed-for-grafana.html, which suggests the intended integration path is a backend that translates some other system's alert format into Alerta's. Whoever writes that translation owns it.

The API server, the database, and the console are three separate things

Alerta is not a single process. The Python package installs a WSGI application plus an alertad command, and setup.py declares the console script entry point alertad = alerta.commands:cli. Everything else is optional except the database. The README says the only mandatory dependency is MongoDB or PostgreSQL, with Postgres 13 or better and MongoDB 6.0 or better. Release 9 requires Python 3.9 or higher.

The database choice is not cosmetic. setup.py puts pymongo behind the mongodb extra and psycopg2 behind the postgres extra, so the driver you install determines the backend you can talk to. The development instructions show the Postgres path explicitly through the DATABASE_URL environment variable, and the test suite is split the same way: TOXENV=postgres and TOXENV=mongodb run separate suites, and the README notes that running all tests requires a local Postgres and MongoDB database running simultaneously. That is a meaningful operational detail. A single deployment uses one backend, but contributors and anyone validating a change against upstream's own tests need both.

The web console is a separate download entirely. It lives in its own repository, alerta-webui, and the README's installation steps fetch a tarball from that repository's latest release and serve the extracted dist directory with Python's built-in HTTP server. So the server, the database and the console each have their own upgrade path and their own release cadence. That is the price of the decoupled design, and it is the first thing to plan for.

Installing the server and sending your first alert

The README gives two installation routes. The pip route assumes you already have a database running. On Debian or Ubuntu the documented commands install and start MongoDB:

bash
sudo apt-get install -y mongodb-org
mongod

On CentOS or RHEL the package name differs, and the README gives sudo yum install -y mongodb followed by mongod. With a database up, the server and the command line client install together:

bash
pip install alerta-server alerta
alertad run

That starts the API server. Configuration is read from /etc/alertad.conf by default, or from whatever path you point ALERTA_SVR_CONF_FILE at:

bash
ALERTA_SVR_CONF_FILE=~/.alertad.conf
echo "DEBUG=True" > $ALERTA_SVR_CONF_FILE

The Docker route is shorter and is the one to try first if you only want to see the thing work. The repository's docker-compose.yml defines two services, api and db. The api service uses the image ghcr.io/alerta/alerta-api and publishes port 8080, and it receives DATABASE_URL=postgres://postgres:postgres@db:5432/monitoring. The db service runs the postgres image with POSTGRES_DB, POSTGRES_USER and POSTGRES_PASSWORD all set to postgres. Note that the db service's ports entry is 5432 with no host mapping, so the database is reachable only from inside the compose network. The README also points at alerta/docker-alerta for a fuller container setup.

Either way you still need the console. The README's steps download alerta-webui.tar.gz from the alerta-webui latest release, extract it, change into dist, and run python3 -m http.server 8000, then browse to http://localhost:8000. Serving the console with the standard library HTTP server is fine for a look; it is not a deployment.

The plugin hooks are where policy lives

Setup.py registers eight entry points under alerta.plugins. They are remote_ip, reject, heartbeat, blackout, acked_by, escalate, forwarder and timeout. Read that list as the set of behaviours Alerta expects to be pluggable: rejecting alerts from unknown sources, receiving heartbeats, suppressing alerts during a blackout window, recording who acknowledged what, escalating severity, forwarding alerts onward, and timing out alerts that were never resolved.

The important point is that these are hooks, not a policy engine. If your requirement is "page the on-call only when three related alerts fire within ten minutes," nothing in that list does it for you. The forwarder plugin moves alerts somewhere else; the escalate plugin changes severity. Correlation logic is your problem, expressed either in a custom plugin or upstream in whatever sends the alert.

This is a fair design for the stated aim of minimal configuration, but it shifts real work onto the adopter. The repository has an examples/plugins/ directory, which is a reasonable starting point, and the docs site at docs.alerta.io is where the README sends you for anything beyond the basics. The README itself does not document the plugin interface, so treat the examples and the source as the reference.

Where Alerta is the wrong tool

Alerta does not generate alerts. There is no scheduler, no check runner, no probe. If you are looking for something that watches an endpoint and tells you when it stops responding, Alerta is the wrong layer and you will need a separate system to do the watching.

The database requirement is a real cost, not a formality. You are running MongoDB 6.0 or better, or PostgreSQL 13 or better, in production, with backups and upgrades. A small team that wanted a single binary will find this heavier than expected. The README does not describe a rollback path for a failed upgrade, and it does not document a migration procedure between the two supported backends. If you start on MongoDB and later want Postgres, the documentation gives you no migration route, so that choice is close to permanent.

The console is also a separate artifact with its own release. Upgrading the API server does not upgrade the web UI, and the README does not state a compatibility matrix between them. The pip install path assumes you already have a database running and reachable, which is easy to miss on a first read.

Finally, the README does not document rollback, rate limiting, or retention policy for old alerts. Those are the questions to ask before a production rollout, and the documentation is silent on them.

How it compares to Prometheus Alertmanager

The obvious comparison is Prometheus Alertmanager. Both receive alerts over an API and both handle deduplication and routing in some form, but they differ in where the logic sits and what the alert model looks like.

Alertmanager is built around Prometheus's label-based data model. Its routing tree, grouping and inhibition rules are expressed in a YAML configuration file, and the whole thing is designed to sit downstream of Prometheus and push notifications out to receivers. Alerta is database-backed and source-agnostic. Its README explicitly claims minimal configuration so that it accepts alerts from any source, and the backend examples in the repository are the mechanism for that. Alerta keeps alerts in MongoDB or PostgreSQL, which means the alert has a lifecycle you can query later; Alertmanager's model is closer to transient notification routing.

If your world is already Prometheus and you want notification routing with silence and inhibition, Alertmanager is the tighter fit and you avoid operating a database for it. If you have several unrelated alert sources, want a persistent record, and want a console humans can work in, Alerta's model is the better match. The two are not mutually exclusive: an Alertmanager receiver can forward into Alerta, and the repository's examples/backends/ directory is where that kind of translation would live.

Maintenance, licensing and upgrade cost

The last push to the default branch was on 2026-06-19, and the repository is not archived. The most recent release listed is v9.1.0 from 2026-03-28, following v9.0.4 in September 2024 and v9.0.3 in April 2024. Read that cadence honestly: a major release in early 2026, then a gap of roughly a year and a half between v9.0.4 and v9.1.0 before it. This is a project that ships when it ships, not one with a frequent release train.

That matters for upgrade planning in a specific way. Because the server, the web console and the database are separate artifacts, an upgrade is not one action. You update the Python package or the container image, you may need to update the console tarball independently, and you may need a database migration that the README does not describe. Budget for reading CHANGELOG.md before each move; it is a top-level file in the repository.

Licensing is straightforward. The project is under the Apache License, Version 2.0, and the README carries the standard notice, copyright 2012-2023 Nick Satterly. Apache-2.0 permits commercial use and modification with the usual conditions around notices and the absence of warranty. The README also notes the project can be deployed to Heroku, AWS EC2 or Google Cloud Platform through separate repositories. That is an operational convenience, not a licensing consideration, but it does mean the deployment tooling lives outside this repository and carries its own maintenance status.

Editorial conclusion

Adopt Alerta if you already run several monitoring systems and want one API and one console in front of them, and you are willing to operate MongoDB or PostgreSQL yourself. Do not adopt it if you expect a turnkey SaaS replacement with built-in check scheduling; Alerta receives alerts, it does not generate them. Before committing, verify which database backend you will run, since the README lists MongoDB and PostgreSQL as equally mandatory alternatives but the test suite requires both to be present locally, and confirm that the web console tarball from the alerta-webui releases page is the version you intend to serve.

Frequently asked questions

What is Alerta for?

Alerta is an alert aggregation server. It receives alerts from other systems through an API and presents them in a web console, rather than generating alerts itself. The README describes its aims as being scalable through a decoupled design, accepting alerts from any source with minimal configuration, and giving quick at-a-glance visualisation.

What is the Alerta dashboard?

The dashboard is the web console, distributed separately from the server in the alerta-webui repository. The README's install steps download alerta-webui.tar.gz from that repository's latest release, extract it, and serve the dist directory with python3 -m http.server 8000.

How do you use Alerta?

You install the server and client with pip install alerta-server alerta, run alertad run, then point your existing monitoring systems at the API so they post alerts into it. The README also provides a Docker Compose file with an api service and a postgres db service for a container-based setup.

Official sources

  1. alerta/alerta on GitHub
  2. License: Apache-2.0
  3. Project website
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/alerta-alerta.svg)](https://hysenlabs.com/projects/alerta-alerta)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/alerta-alerta.svg)](https://hysenlabs.com/projects/alerta-alerta)

Was this useful?