Umami vs Plausible vs Matomo for Self-Hosted Analytics

what to look for in a self-hosted analytics platform

There are dozens of web traffic analytics platforms that support self-hosting. It would a waste of time to try to comprehensively evaluate and compare all of them because, at the end of the day, any of them would likely meet my needs.

Here are the criteria I used to winnow down the field:

• Popularity: as with any open source tool, community size matters for both support and longevity.
• Simplicity: I don’t want to waste time setting up and maintaining features that I’m not going to use.
• Portability: I want a platform that allows as much configuration as possible to be handled via Docker compose and environment variables.
• Privacy: I don’t want to have to display cookie consent banners to my visitors.
• Performance: I don’t want the analytics platform to noticeably affect the performance of my website in the browser, and I want to keep server resource requirements to a minimum.

Judging by these criteria, I ended up choosing Umami, with Plausible as a close second. The rest of this article digs into some key differences between the platforms I evaluated and my rationale for choosing Umami.

Matomo

Matomo is the “original” open source analytics platform, having launched as Piwik in 2007. It remains the most popular self-hosted analytics platform according to DockerHub download statistics, with over 100 million downloads of the official Docker image. Matomo is built in PHP, and uses either MySQL or MariaDB for storage.

Matomo does have an official setup guide in their docker container repo. Because Matomo is built in PHP, it requires a web server like Apache or Nginx to serve both its dashboard and API endpoints, which adds additional configuration complexity that I find off-putting. There are community distributions that provide a more complete solution via a complete docker compose stack, but this “batteries included” distribution includes an eyebrow-raising 6 separate containers.

You do get more for dealing with all of this complexity. Matomo has a richer set of features than either Plausible or Umami, including capabilities like session recording and heatmaps to provide more granular insight into user activity on a page. That capability comes at the cost of a much heavier client-side JavaScript payload, weighing in at ~23kb vs ~1kb for Plausible or Umami.

Matomo offers a wider range of integrations with Content Management Systems like WordPress and Drupal, but my requirements are more bare-bones: I’m fine adding a script tag to the global layout of an Astro or SvelteKit project. Matomo’s marketing team has put together this comparison with Plausible; most of these points also apply to Umami.

I’m not going to be using Matomo because:

• I don’t want to deal with PHP and its peculiarities.
• The additional features like A/B testing and heatmaps are overkill for my purposes.
• Remember those 6 separate containers?
• The client-side JavaScript payload is too heavy.

Plausible

Plausible takes second place in popularity, behind Matomo, among self-hosted analytics platforms. Plausible bills itself as a lightweight alternative to both Google Analytics and Matomo. Simplicity and efficiency are Plausible’s main selling points. It doesn’t include features like session recording, which results in a client-side script that’s only ~1kb. Dashboarding and reporting are likewise decluttered by the omission of stats that simply aren’t collected.

Plausible’s server components are written in Elixir, a functional language on the Erlang VM that’s known for handling concurrency efficiently and robustly. Data storage is in ClickHouse, which is a key disinguishing feature compared to Umami, which uses Postgres for storage. ClickHouse is specially-designed for fast analytics queries and will perform better than Postgres at scale, but it does require considerably more RAM than Postgres, which could eat into the resources available to deploy other applications on your server. For a small-to-medium website, the difference in analytics query performance is likely to be minimal and the additional RAM requirements bite harder.

Plausible provides better first-party support for self hosting than any other analytics tool that I’ve come across. Plausible has an official Community Edition repository that’s meant to be cloned, customized, and deployed on a single instance with docker compose. Key configuration options are documented directly in the compose.yml file, which is a thoughtful touch, as well as a full configuration guide.

Umami

Umami is remarkably similar to Plausible feature-wise and launched at about the same time (2020 vs 2019). Like Plausible, Umami focuses on simplicity and privacy, with cookie-free data collection and a lightweight client-side script (~2kb).

Umami is written in React, uses Redux for state management, and uses Next.js for its backend API routes. This is arguably a less efficient tech stack than Plausible’s Elixir backend, but whether that matters for your use case depends on scale. As mentioned above, Umami uses Postgres to store analytics data, so you should expect a smaller server resource footprint and slower analytical query performance compared to Plausible’s ClickHouse backend. You may or may not notice a difference.

The strongest distinguishing feature Umami has relative to Plausible is that it makes it easy to rename both your tracker script and the API endpoint for a self-hosted deployment using environment variables. Renaming the script and endpoint can help you bypass ad blockers, which can and do block Plausible’s plausible.js client-side script even when it’s hosted on your own domain. Plausible doesn’t offer a convenient way to do this, forcing you to handle the renaming in your proxy configuration instead.

Umami does include a docker compose file and instructions for docker installation in its documentation. The documentation is not as comprehensive as Plausible’s, but this is partially because Umami omits some features that make Plausible setup more complicated (see next section).

One other detail that distinguishes Umami from Plausible is that Umami collects geographic data at the city level, while Plausible only collects country-level data. Plausible does offer more detailed geographic data on its paid cloud plans, but for self-hosting you’re limited to country-level data. If you’re self hosting and want location data at the region, state, or city level, Umami is the better choice.

user management: Umami is simpler

Umami also distinguishes itself from Plausible by having simpler user management. Umami installs with a single, horrifically insecure admin account, which you must immediately change manually through the user interface. Additional users can only be added by an admin user through the user interface, which is fine if you’re using Umami on a personal website or with a small team.

Plausible, on the other hand, expects you to create users through a sign-up form on the web interface’s login page. User registration can be disabled through an environment variable, but you need to enable it initially to create your own account. New user accounts require email verification, which requires an SMTP server; about half of the configuration variables in the Plausible docker compose stack relate to email verification. If you don’t have or want to set up your own mail server, you’ll need to run a script against Plausible’s Postgres database (which only stores user information, not analytics data) to manually set the email verification flag.

Umami’s user management is more straightforward for self-hosted analytics on personal websites. I don’t foresee needing or wanting users to be able to create their own accounts on my analytics server, which I’m not going to make publicly available. And while Plausible’s additional complexity is a one-time ordeal, it adds enough friction to tilt the balance in favor of Umami for my use case.

dashboard UI: Plausible is more polished

Plausible’s dashboard is more polished and easier-to-use than Umami’s, although it does come across as more branded. Here’s a link to the demo Plausible Dashboard, which you can compare to the demo Umami Dashboard. Clicking on a facet like “Country” in the Plausible dashboard automatically applies a filter to the data, so you can for instance see which pages users from a given country are visiting. This is a feature I’d like to see in Umami.

my choice: Umami

I’m choosing Umami over Plausible for my self-hosted analytics platform because:

• Umami makes it easier to rename the tracker script and API endpoint for bypassing ad blockers, allowing for more complete data collection.
• Umami has simpler user management, not requiring an additional database container just for user information or an email server for account verification.
• I plan to deploy Umami behind a Traefik reverse proxy, so I don’t need Plausible’s SSL termination and Let’s Encrypt integration.
• I’m more concerned about server resource requirements than analytics query performance, so I prefer Umami’s Postgres backend over Plausible’s ClickHouse backend. Moreover, I’m already familiar and comfortable with Postgres, whereas ClickHouse is new to me.

appendix: other analytics platforms

There are a few other platforms that I collected some notes on before removing them from further consideration. Here are those notes, make of them what you will.

GoatCounter

I like GoatCounter’s simplicity and low server resource footprint, and its creator seems like a good guy with a similar view regarding analytics on personal websites. The deal-breaker for me is the lack of an official docker image; the author claims that Docker isn’t necessary because GoatCounter has no external dependencies, but the rest of my server infrastructure is configured using docker compose and I’d prefer to keep things consistent for portability. I could build my own docker image based on one of the abandoned community distributions, but I’d feel more comfortable using a platform with first-class Docker support.

Swetrix

Swetrix is relatively new, but I’ve seen it recommended in a few Reddit posts. They do have a self-hosting guide and a repository with a docker compose file that seems to be under active development (at the time of this writing). Swetrix has some cool features like a self-hosted CAPTCHA tool. Worth keeping an eye on.

Fathom

Fathom does offer a self-hosted option, Fathom Lite, but it’s not as feature-complete as either Plausible or Umami. It also seems like abandonware: the Docker container was last updated 5 years ago, and the example docker-compose file hasn’t been updated in 6 years. So despite having seen Fathom mentioned in various places around the web, I’m not going to evaluate it further because it seems like their self-hosted offering has fallen by the wayside.

PostHog

PostHog has a self-hosted version that’s prepared as a docker compose stack. The docker compose stack installs with a script, which is interesting, but there are several comments on the documentation page outlining unresovled technical issues, which comes across as a red flag. Another red flag comes from the fact that the documentation for the self-hosted version is absolutely dripping with suggestions that you should be using their cloud offering, which makes me question whether they’ll sunset the self-hosted version in the future.

Overall PostHog seems like way too intense a platform for what I’m looking for right now, much like Matomo. Its session recording features could be useful to track user journeys, but it’s unclear how much of an impact having those scripts available would have on website loading performance when they aren’t being used. Much of PostHog’s functionality comes from capturing custom events in your frontend code, which is similar to simpler platforms like Plausible. PostHog also includes additional capabilities like feature flags, which allow you to conditionally enable certain features in your frontend code based on an API response from your analytics server (this sounds like it could meaningfully increase latency, unless you request these feature flags on the server side).

PostHog uses a django backend to capture analytics; I believe the frontend is React. Data storage is in ClickHouse. The client-side script is a true hog, at 52kb gzipped.

Countly

Countly bills itself as a “product analytics platform”, which implies more features and a larger client-side script payload than I’m looking for. They do get a mention for supporting Docker compose in production and providing decent Docker-based setup documentation.

side note: server-side tracking capabilities

Of the platforms mentioned here, only Matomo and GoatCounter are able to ingest and analyze traffic from server logfiles. The rest of them all rely entirely on client-side data collection via JavaScript running in the browser¹.

I briefly considered using GoAccess to analyze logs from my Traefik reverse proxy, the chokepoint through which all of my traffic flows, but ultimately concluded that server-side tracking is more trouble than it’s worth.