Google Analytics has dominated website analytics for nearly two decades, but in 2026 the landscape is changing. Privacy regulations like GDPR and CCPA have made cookie banners ubiquitous, third-party tracking is increasingly blocked by browsers, and users are more privacy-conscious than ever. For self-hosters and privacy advocates, there’s a better way: self-hosted analytics.

💡 This article contains affiliate links. If you buy through them, we earn a small commission at no extra cost to you. Learn more.

Self-hosted analytics platforms give you complete control over your data, eliminate third-party tracking, and often don’t require cookie consent banners. In this comprehensive guide, we’ll compare the two most popular options—Umami and Plausible—and show you how to set them up on Docker.

Why Self-Host Your Analytics?

Before diving into specific platforms, let’s understand why self-hosting analytics makes sense in 2026:

Privacy and GDPR compliance: When you self-host, your visitor data never leaves your server. No third-party processors means simpler GDPR compliance and often no cookie consent requirement.

Data ownership: Your analytics data is yours forever. No vendor lock-in, no surprise API changes, no risk of losing historical data if a service shuts down.

No ad blocker interference: Self-hosted analytics on your own domain bypass most ad blockers. While you should respect users who actively block analytics, self-hosting dramatically reduces the false negatives from default browser protections against tracking.

Performance: Loading analytics from your own domain is faster than calling out to Google’s servers, especially for international visitors.

Cost: After the initial setup, self-hosted analytics cost only what you pay for server resources—typically a few dollars per month or less.

Customization: Open-source platforms can be modified, extended, and integrated with your existing infrastructure.

Umami vs Plausible: Overview

Both Umami and Plausible are open-source, privacy-focused analytics platforms designed as Google Analytics alternatives. They share many philosophies but differ in implementation, features, and licensing.

Umami

License: MIT (completely open-source)
GitHub Stars: ~20,000+
Tech Stack: Next.js (React), PostgreSQL or MySQL
Cloud Offering: Umami Cloud (paid)

Umami is the more flexible and feature-rich option. It’s built with Next.js and supports both PostgreSQL and MySQL databases. The MIT license means you can do virtually anything with it, including white-labeling for commercial use.

Plausible

License: AGPL v3 (open-source with restrictions)
GitHub Stars: ~18,000+
Tech Stack: Elixir/Phoenix, PostgreSQL, ClickHouse
Cloud Offering: Plausible Analytics (paid, primary business model)

Plausible is designed to be extremely simple and minimalist. It’s built with Elixir and uses ClickHouse for high-performance data storage. The AGPL license means you must open-source any modifications if you distribute the software, which is primarily intended to prevent competitors from offering Plausible as a commercial service without contributing back.

Feature Comparison

Dashboard and User Interface

Umami offers a clean, modern dashboard with multiple viewing options. You can see real-time visitors, page views, referrers, browsers, OS, devices, countries, and custom events. The interface supports multiple websites from one installation, with user management and role-based access control.

Plausible takes minimalism to heart. The dashboard displays all key metrics on a single page with no navigation required. It’s incredibly fast to load and easy to understand at a glance. Like Umami, it supports multiple sites and has simple goal tracking.

Winner: Tie. Umami for power users who want more data and customization; Plausible for those who value simplicity.

Privacy Features

Both platforms are privacy-first by design:

  • No cookies required
  • No personal data collected
  • No cross-site or cross-device tracking
  • Aggregate data only
  • Compliant with GDPR, CCPA, and PECR

Plausible goes slightly further by being explicitly designed to not require cookie consent under GDPR, with documentation explaining the legal reasoning. Both platforms hash IP addresses and don’t store raw IPs.

Winner: Tie. Both are excellent for privacy.

Performance and Scalability

Umami uses PostgreSQL or MySQL for data storage, which is familiar to most self-hosters but can become sluggish with millions of pageviews. For small to medium sites (under 1 million pageviews/month), performance is excellent.

Plausible uses ClickHouse, a columnar database designed for analytics workloads. This makes it significantly faster at handling large datasets. However, ClickHouse requires more system resources and expertise to manage.

Winner: Plausible for high-traffic sites; Umami for typical self-hosted workloads.

Customization and Extensibility

Umami has a robust API, supports custom events with any properties you define, and allows multiple users with different permission levels. You can track events like button clicks, form submissions, or custom actions with detailed metadata.

Plausible focuses on simplicity. It supports custom events and goals but with less flexibility than Umami. The API is more limited, primarily designed for reading data rather than building integrations.

Winner: Umami for developers and power users.

Docker and Deployment

Both platforms have official Docker images and Docker Compose examples.

Umami is easier to deploy. It works with both PostgreSQL and MySQL, databases most self-hosters already run. The Docker setup is straightforward and well-documented.

Plausible requires PostgreSQL, ClickHouse, and an Elixir runtime. The Docker Compose file is more complex, and the resource requirements are higher. However, the official documentation is excellent.

Winner: Umami for ease of deployment.

Tracking Script Size

Umami: ~2-3 KB (compressed)
Plausible: ~1 KB (compressed)

Both are extremely lightweight compared to Google Analytics (45+ KB). The difference is negligible for most use cases.

Winner: Plausible, but both are excellent.

Cost (Self-Hosted)

Both are free to self-host. Your only costs are server resources.

Umami runs comfortably on a lightweight VPS or even a Raspberry Pi for low-traffic sites. Expect 256-512MB RAM usage for small deployments.

Plausible requires more resources due to ClickHouse. Budget at least 1-2GB RAM for a comfortable deployment.

Winner: Umami for budget-conscious self-hosters.

Setting Up Umami on Docker

Let’s walk through a complete Umami setup using Docker Compose.

Prerequisites

  • Docker and Docker Compose installed
  • A domain or subdomain (e.g., analytics.yourdomain.com)
  • Reverse proxy (Traefik, Caddy, or Nginx)

Step 1: Create Docker Compose File

Create a directory for Umami:

1
2
3

mkdir -p ~/docker/umami
cd ~/docker/umami
nano docker-compose.yml

Add this configuration:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

version: '3'

services:
  umami:
    image: ghcr.io/umami-software/umami:postgresql-latest
    container_name: umami
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgresql://umami:umami_password@db:5432/umami
      DATABASE_TYPE: postgresql
      APP_SECRET: your-random-secret-key-change-this
    depends_on:
      - db
    restart: unless-stopped

  db:
    image: postgres:15-alpine
    container_name: umami-db
    environment:
      POSTGRES_DB: umami
      POSTGRES_USER: umami
      POSTGRES_PASSWORD: umami_password
    volumes:
      - ./data:/var/lib/postgresql/data
    restart: unless-stopped

Important: Replace APP_SECRET with a random string. Generate one with:

1

openssl rand -base64 32

Step 2: Start Umami

1

docker-compose up -d

Umami will be available at http://localhost:3000. The default login is:

  • Username: admin
  • Password: umami

Change this immediately after first login.

Step 3: Configure Reverse Proxy

For Traefik, add these labels to your docker-compose.yml:

1
2
3
4
5
6

labels:
  - "traefik.enable=true"
  - "traefik.http.routers.umami.rule=Host(`analytics.yourdomain.com`)"
  - "traefik.http.routers.umami.entrypoints=websecure"
  - "traefik.http.routers.umami.tls.certresolver=letsencrypt"
  - "traefik.http.services.umami.loadbalancer.server.port=3000"

Step 4: Add Website to Umami

  1. Log in to Umami
  2. Go to Settings → Websites
  3. Click “Add website”
  4. Enter your website name and domain
  5. Copy the tracking code

Step 5: Add Tracking Script

Add this to your website’s <head> section:

1

<script async src="https://analytics.yourdomain.com/script.js" data-website-id="your-website-id"></script>

That’s it! Umami will start collecting analytics data.

Setting Up Plausible on Docker

Plausible’s setup is more complex due to ClickHouse, but still manageable.

Step 1: Clone Hosting Repository

Plausible provides an official self-hosting repository:

1
2

git clone https://github.com/plausible/hosting
cd hosting

Step 2: Configure Environment

Generate a secret key:

1

openssl rand -base64 64

Edit plausible-conf.env:

1
2
3

BASE_URL=https://analytics.yourdomain.com
SECRET_KEY_BASE=your-generated-secret-key
TOTP_VAULT_KEY=your-second-random-key

Step 3: Start Plausible

1

docker-compose up -d

Wait a few minutes for ClickHouse to initialize.

Step 4: Create Admin Account

1

docker-compose exec plausible /bin/sh -c "plausible_db create-admin"

Follow prompts to create your admin account.

Step 5: Configure Reverse Proxy

Add Traefik labels or configure your reverse proxy to route analytics.yourdomain.com to port 8000.

Step 6: Add Website and Tracking Script

Log in to Plausible, add your website, and insert the tracking script:

1

<script defer data-domain="yourdomain.com" src="https://analytics.yourdomain.com/js/script.js"></script>

Advanced Features

Custom Events in Umami

Track custom events with JavaScript:

1

umami.track('button-click', { button: 'signup', page: 'pricing' });

Goals in Plausible

Define goals in Settings → Goals. Track with:

1

plausible('goal-name');

Or use CSS classes:

1

<button class="plausible-event-name=Signup">Sign Up</button>

API Access

Both platforms offer APIs for programmatic access:

Umami: REST API at /api/ with bearer token authentication.
Plausible: Stats API requires API key generation in settings.

Hardware Recommendations

For a typical self-hosted analytics deployment serving 5-10 websites with moderate traffic:

Umami: 2 CPU cores, 2GB RAM, 20GB storage
Plausible: 4 CPU cores, 4GB RAM, 50GB storage (due to ClickHouse)

A modern mini PC with an Intel N100 processor is perfect for both. Alternatively, a VPS like Hetzner’s CX21 (€5.88/month) handles Umami easily, while Plausible might need CX31 (€9.52/month).

Maintenance and Backups

Umami Backups

Back up the PostgreSQL database:

1

docker exec umami-db pg_dump -U umami umami > umami-backup.sql

Automate with cron:

1

0 2 * * * docker exec umami-db pg_dump -U umami umami | gzip > /backup/umami-$(date +\%Y\%m\%d).sql.gz

Plausible Backups

Plausible’s backup is more complex due to ClickHouse:

1
2

docker-compose exec plausible_db pg_dump -U postgres plausible_db > plausible-postgres-backup.sql
docker-compose exec plausible_events_db clickhouse-client --query="BACKUP DATABASE plausible_events_db TO Disk('backups', 'backup.zip')"

Migration from Google Analytics

Both platforms can coexist with Google Analytics during transition:

  1. Install self-hosted analytics alongside GA
  2. Compare data for 2-4 weeks
  3. Adjust expectations (self-hosted analytics show fewer users due to ad blocker bypass and no cross-domain tracking)
  4. Remove Google Analytics when comfortable

Important: Self-hosted analytics will show different numbers than Google Analytics. This is expected and doesn’t mean your data is wrong—it’s just more accurate in many cases because it’s not blocked.

Which Should You Choose?

Choose Umami if:

  • You want maximum flexibility and customization
  • You need detailed event tracking with custom properties
  • You prefer familiar databases (PostgreSQL/MySQL)
  • You’re running multiple sites with different teams/users
  • You want the easiest Docker deployment

Choose Plausible if:

  • You value extreme simplicity and minimalism
  • You have high-traffic websites (millions of pageviews)
  • You want the smallest tracking script
  • You prefer opinionated, focused tools
  • You have resources to run ClickHouse

My recommendation: For most self-hosters, Umami is the better choice. It’s easier to deploy, runs on familiar infrastructure, and offers more features without being overwhelming. Plausible is excellent, but its advantages only become clear at scale or if you deeply value its specific philosophy.

Common Issues and Troubleshooting

Umami Not Tracking

  1. Check browser console for errors
  2. Verify script URL is correct and accessible
  3. Ensure website ID is correct
  4. Check if ad blocker is interfering (use a different domain if needed)

Plausible ClickHouse Errors

ClickHouse initialization can fail if:

  • Insufficient RAM (increase to 4GB minimum)
  • Slow storage (use SSD, not HDD)
  • Corrupted data (remove volumes and recreate)

High Resource Usage

If analytics are consuming too many resources:

  • Set up log rotation for Docker containers
  • Increase data retention limits (delete old data)
  • Move database to faster storage

Conclusion

Self-hosted analytics in 2026 are mature, reliable, and essential for privacy-conscious websites. Both Umami and Plausible deliver on the promise of GDPR-compliant, lightweight, and accurate analytics without sacrificing your visitors’ privacy.

For most self-hosters, Umami offers the best balance of features, ease of deployment, and flexibility. It’s powerful enough for complex setups but simple enough for beginners. Plausible excels in high-traffic scenarios and appeals to those who want the simplest possible solution.

Whichever you choose, you’ll gain complete control over your analytics data, improve your site’s performance, and respect your visitors’ privacy. That’s a win-win-win.

Further Resources

Ready to take control of your website analytics? Set up Umami or Plausible today and never worry about Google Analytics cookie banners again.