Logo

Aliaksandr

Tsykin

Umami vs Google Analytics vs Plausible: The Ultimate Web Analytics Comparison

Compare Umami, Plausible, and Google Analytics to find the best web analytics tool. Learn about setup, pricing, features and data quality of each tool.

Aliaksandr TsykinAliaksandr Tsykin|
Umami vs Google Analytics vs Plausible: The Ultimate Web Analytics Comparison

Video

coming soon …

TLDR

Quick comparison per feature and aspect:

AspectGA4Umami self-hostedPlausible self-hosted
Web, Summary dashboard✅✅✅
Web, Filters for viewed data✅✅✅
Web, Pre-built reports✅✅✅
Web, Custom reports builder✅✅❌
Web, UXSimple when using pre-built reports, complicated for advanced usage.Very good for both pre-built and custom reporting.Very primitive, lacking.
Web, Data exportExport to Google Sheets, CSV and TSVOnly copy-paste from custom reports (kinda like TSV)Export to CSV (but only for summary dashboard)
Stats API❌✅❌ Not available when self-hosting
Direct SQL query✅ Only when exporting to BigQuery✅❌ Unusable and hashed data
Initial setupA lot of steps, somewhat frustratingVery straight-forwardVery straight-forward
Impact on page load speedApprox 500ms slow down2 KB script, almost no effect3 KB script, almost no effect
PricingFree if not using BigQuery exportapprox. $2 when self-hosting on Railwayapprox. $8 when self-hosting on Railway
Data quality and availabilityPoor, only a small portion of website traffic data is availableBest quality and metrics availabilityNot all metrics are being reported, but data quality is high
Umami is the best tool for web analytics when compared to Google Analytics and Plausible.
Skip to data quality comparison.

Intro

If you have a website, you might want to collect data about how users interact with it:

  • what pages do they visit?
  • what pages are the most engaging?
  • what actions are they performing?

For that we usually use web analytics tools. In this post I am comparing 3 tools after 30 days of using them:

  • Google Analytics 4 (GA4)
  • Umami
  • Plausible

Why these tools?

Google Analytics 4 is free and became a default choise for many websites.

Umami and Plausible are both open-source and easy to self-host, which is exactly what I did using templates on Railway.app

Notes:

  • I tried using Matomo Analytics, but it just didn’t work — installation script was not being detected by Matomo itself, so it will not be a part of this comparison
  • Although PostHog is open-source and theoretically can be self-hosted, I couldn’t do it (probably a skill issue)

1. Initial setup and pricing

Google Analytics

As mentioned, Google Analytics if completely free. I recommend setting it up using Google Tag Manager (GTM), since you will still need GTM for creating custom events in the future.

My guide for Google Tag Manager & Next.js App router setup

Umami and Plausible

Since I am self-hosting both of these tools, I don’t pay a subscription fee, but I do pay for hosting them on Railway. Setup for both of these tools is very similar:

When it comes to pricing when self-hosting, they differ significantly:

Bill from railway.app for self-hosting Umami and Plausible for 30 days

Bill from railway.app for self-hosting Umami and Plausible for 30 days

Update 2024-12-17: I am now getting different charge on Railway for both of these services. I will update this screenshot once I get more bills.

Pricing for 30 days of usage

  • Umami
    • Self-hosted on Railway: $1.24
    • Official Hobby plan: $0
    • Official Pro plan: $20
  • Plausible
    • Self-hosted on Railway: $7.66
    • Official Growth plan: $9
    • Official Business plan: $19

This difference when self-hosting is caused by RAM usage of each service:

  • Umami RAM usage
    • Umami service: 250 MB
    • postgres: 80 MB
  • Plausible RAM usage
    • Plausible service: 450 MB
    • Clickhouse service: 400 MB
    • postgres: 100 MB
In conclusion: you can definitely save money by self-hosting Umami and Plausible if you plan to use them for multiple websites or have substantial traffic to one of your websites.

2. Adding custom events

If you want to track custom events, like submitting a form, adding product to cart or completing a purchase — you will need to do some extra work.

Google Analytics

As mentioned, this is done by adding tag and a trigger in Google Tag Manager (GTM). But the actual experience is pretty awful and it takes approximately 25 hours to see data that’s collected for your custom events:
  1. write dataLayer.push script (ex. for button onClick)
  2. create tag in GTM
  3. create trigger in GTM
  4. create dataLayer variable (DLV) for each event property in GTM
  5. pass event prop and value from DLV into created GTM tag
  6. publish new version of GTM container
  7. wait for GA4 to propagate new event props (approx. 24h)
  8. add custom definitions to GA4 for each event prop
  9. only now data is being collected
This entire process takes about 25 hours. This is pretty bad, especially considering that every tag, trigger or variable that you add into GTM makes script’s size bigger and makes your website slower.

So you you are planning to heavily use custom events in GA4 — prepare yourself for quite the adventure.

Umami

Umami has umami.track() function that can be used to track custom events and properties.
Umami documentation for tracker functions

Here’s the example usage of this tracker function in a React component:

export const UmamiTrackedButton = () => {
  const eventData = {
    value: "99",
    currency: "USD",
    product_id: "abcd",
  };

  const handleClick = () => {
    umami.track("purchase", eventData);
  };

  return <button onClick={handleClick}>Track</button>;
};

Once this button is clicked, the event data will immidiately show in Umami’s dashboard. No extra steps are required.

Note: Umami also has umami.identify() function that can be used to easily identify sessions of the same user from different devices, which is very useful. I consider it a gamechanger fore cross-device and cross-session traffic analytics.

Plausible

Initial steps for tracking custom events with Plausible are quite similar to Umami:

export const PlausibleTrackedButton = () => {
  const eventData = {
    value: "99",
    currency: "USD",
    product_id: "abcd",
  };

  const handleClick = () => {
    plausible("purchase", {
      props: eventData,
    });
  };

  return <button onClick={handleClick}>Track</button>;
};
But in order to start actually collecting data for each property of a custom event — you need to manually add each custom event property in Plausible dashboard’s settings.
Screenshot: Plausible > Site settings > Custom properties

Screenshot: Plausible > Site settings > Custom properties

This extra step might not be a dealbreaker, but you might spend some time on adding each property during initial setup.

Also, there’s always a chance that you will just forget to do it after adding custom events and remember only when accessing the data, which might be very frustrating.

3. Accessing data

Once the data is collected, you would want to access it.

Usually, there are two methods of accessing such data:

  • via web interface
  • programmatically, using API or SQL queries

All 3 tools have a web interface for viewing data, but the experience and features are very different.

For summary of accessing data via web interface refer to TLDR section

Accessing data programmatically via API or SQL

For programmatic data access, some extra steps are required.

Google Analytics

Google Analytics has no stats API.

The only way to access raw data is by configuring export to BigQuery, which is a Google Cloud serverless data storage. It allows you to:

  • query data using SQL
  • save and organize queries

This is a paid feature, since you will be using BigQuery on Google Cloud. Unfortunately, I don’t have specific numbers on how much it can cost.

Umami

1. Umami stats API
Using Umami stats API is very easy and well-documented. Returned data is well-structured and is easy to use.
2. Directly querying Umami postgres database
I would not recommend querying Umami’s postgres database directly, but nothing can stop you if you really want or need to. For example, I use direct access to Umami’s database to make reserve copies of the data.
Since Umami is open-source - you can refer to it’s prisma.schema file in the official repo.

Plausible

1. Plausible stats API

Plausible stats API doesn’t work when self-hosting, it’s only for cloud users.

2. Directly querying Plausible postgres database
Theoretically, you can access Plausible postgres database, but it does not contain all the data and some of it is hashed. I think it’s because Plausible uses Clickhouse under the hood, so there’s no reason to do this.

4. Data quality

This is the most important part of the comparison. If the data is unusable — why would you even consider the tool?

When analyzing website traffic, I am interested in the following metrics:

  • page views
  • sessions (also called visits)
  • unique visitors (also called users)
  • session duration
  • bounce rate

It also makes sense to put these metrics in a specific context, for example:

  • entire website traffic
  • per page
  • per referrer
  • per location
  • per device type

Here are some reports that let us compare all 3 analytics tools.

Note, that it’s not the entire available data, but only the most representative data for each tool. Watch video version of this comparison for more data samples.

Report 1. Stats for entire website traffic

MetricGA4UmamiPlausible
page views162398392
visits (sessions)186337341
unique visitors (users)103270306
session duration in seconds1567891
bounce rate60%88%81%

Report 2. Page views per page

Page pathGA4UmamiPlausible
/122423
/blog255
/blog/hello-world132
/blog/how-to-add-google-tag-manager-to-nextjs429494
/blog/how-to-deploy-nextjs-to-firebase-hosting65177174
/blog/naming-convention-for-digital-marketing-campaigns222
/blog/nextjs-self-host-google-cloud-vm368788
/contact244

Report 3. Page views per referrer

ReferrerGA4UmamiPlausible
direct15109-
google1229-
reddit3380-
twitter64-
youtube90152-
For this report type, Plausible only has data for users, bounce rate and session duration (no page views or sessions)

Report 4. Visits (sessions) per country

CountryGA4UmamiPlausible
Brazil102117
Canada1175
France476
Germany164
India224037
Indonesia677
Pakistan488
Philippines71110
Thailand132019
United Arab Emirates254
United Kingdom41413
United States385145
For this report type, Plausible only has data for users (no page views, sessions, session duration or bounce rate).

Report 5. Unique visitors (users) per device type

Device typeGA4UmamiPlausible
desktop89242278
mobile172026
tablet072
For this report type, Plausible only has data for users, bounce rate and session duration (no page views, unique visitors).
For this report type, Umami is reporting correct data in summary dashboard, but incorrect data in custom reports builder.

Data quality comparison summary

When comparing metrics that are available in all 3 tools, it’s clear that Umami and Plausible are reporting similar data.

Google Analytics seems to be sampling and/or not making all the data available.

Plausible does not have all the metrics for most of the crucial reports.

Umami easily wins when comparing data quality for both summary dashboard and advanced data analysis.

5. Other notes

5.1 Differences in tracking methods and definitions

There a few quite important differences in how these tools collect data about session duration and how they define bounce rate metric. It’s nor good nor bad, it’s just different. Refer to the official documentation of these tools for full information.

5.2 Google Analytics quirks

Google Analytics separates similar referrers, which makes data less readable, for example reddit / referral AND reddit.com / referral are two different referrers in Google Analytics.

5.3 Umami’s features

Umami’s umami.identify() function is a gamechanger for:
  • measuring data per user ross many user sessions and devices
  • connecting web analytics data with data from your database!

5.3 Server-side tracking

Some of these tools enable server-side tracking, but in different ways.

Google Analytics

You need to create Google Tag Manager Server Container and configure it. You might need help from experienced web analytics specialist to properly configure it.

Also, you can utilize Measurement Protocol for Google Analytics, but there are quiite a few limitations. Quotes from official Measurement Protocol documentation:
  • "You can't send geographic or device information using the Measurement Protocol."
  • "While it's possible to send events to Google Analytics solely with the Measurement Protocol, only partial reporting may be available."

Umami

Use Send Stats API to send any data to Umami’s database. This is as simple as sending a POST request to a route with event’s data in body.
Refer to the official Umami documentation on sending stats via API.

Plausible

As far as I know, Plausible has no way of sending data server-side.

5.4 This article is NOT sponsored

I am in no way affiliated with Umami, Plausible or Google Analytics.

This is not a sponsored article and I wrote it simply out of my frustration when using Google Analytics for many of my or my client’s websites.

Feel free to contact me if you have suggestions or requests for comparisons. I will be happy to connect! 🙂

Table of Contents

Blog by Aliaksandr Tsykin

Learn web development and digital marketing with me!