Feb 10, 2026

Best Self-Hosted Analytics Tools in 2026: Plausible vs Umami vs Matomo vs PostHog

Google Analytics 4 has been around long enough for the dust to settle, and the consensus is grim. The interface is a maze of confusing menus. Reports that took ten seconds in Universal Analytics now require custom explorations and five clicks. The data model changed in ways that broke every dashboard and tutorial that existed before July 2023. And underneath all of it, you are still handing your visitors’ behavioral data to the largest advertising company on the planet.

Meanwhile, GDPR enforcement has gotten teeth. Austria, France, Italy, Denmark, and Finland have all issued rulings or guidance against Google Analytics. The fines are not theoretical anymore — they are real, recurring, and getting larger. If you run a website that serves European visitors, using GA4 without a carefully configured consent mechanism is a legal liability.

The good news is that self-hosted analytics have matured dramatically. Four platforms now cover the full spectrum from simple traffic dashboards to deep product analytics, all running on infrastructure you control. This guide compares them in detail so you can pick the right one for your situation.

We are looking at Plausible Community Edition, Umami, Matomo, and PostHog. Each takes a fundamentally different approach to the same problem, and the right choice depends on what you are building, how much infrastructure you want to manage, and what questions you need your analytics to answer.

TL;DR

Plausible CE is the best all-around choice for content sites, blogs, and marketing pages. Cleanest dashboard, smallest script, no cookies, no consent banner needed. Requires ~1 GB RAM due to ClickHouse.
Umami is the developer favorite. MIT license, 200 MB RAM, deploys in two minutes, full REST API. Best for developers and indie hackers who want something lightweight and hackable.
Matomo is the enterprise Google Analytics replacement. Full feature parity with GA4, plugin ecosystem, heatmaps, session recordings, A/B testing. Heaviest to run, but nothing else matches its depth.
PostHog is a product analytics platform, not a traffic counter. Session recordings, feature flags, A/B testing, surveys, and behavioral funnels. Overkill for blogs, indispensable for SaaS products.
If you just want to pick one and move on: Umami for simplicity, Plausible for polish.

Quick Comparison Table

Before diving into each tool, here is a side-by-side overview of the specs that matter most.

Feature	Plausible CE	Umami	Matomo	PostHog
Tracking Script Size	< 1 KB	~2 KB	~22 KB	~70 KB
Cookie-Free by Default	Yes	Yes	Configurable	No
GDPR Compliant (No Banner)	Yes	Yes	With config	No
Real-Time Dashboard	Yes	Yes	Yes	Yes
Custom Event Tracking	Yes	Yes	Yes	Yes
Goal / Conversion Tracking	Yes	Yes	Yes	Yes
Funnel Analysis	Yes	Basic (via API)	Yes (Premium)	Yes
Session Recording	No	No	Plugin (Paid)	Yes
Heatmaps	No	No	Plugin (Paid)	No
A/B Testing	No	No	Plugin (Paid)	Yes
Feature Flags	No	No	No	Yes
Revenue / E-Commerce	Yes	No	Yes	Yes
Google Search Console	Yes	No	Yes	No
GA Data Import	Yes	No	Yes	No
Tag Manager	No	No	Yes (Built-in)	No
REST API	Yes	Yes	Yes (200+ endpoints)	Yes
Multi-Site Support	Yes	Yes	Yes	Yes
Primary Language	Elixir	Next.js	PHP	Python/TypeScript
Database	ClickHouse + Postgres	PostgreSQL	MySQL/MariaDB	ClickHouse + Postgres
Minimum RAM	~1 GB	~200 MB	~512 MB	~4 GB
License	AGPL v3	MIT	GPL v3	MIT (partial)
Best For	Content sites	Developer projects	GA replacement	Product teams

Now let’s break each one down in detail.

1. Plausible Community Edition

Website: plausible.io License: AGPL v3 GitHub Stars: 21,000+ Written in: Elixir

Overview

Plausible Analytics was designed from scratch as the anti-Google Analytics. The founders, based in the EU, built it around a simple premise: collect the metrics that actually matter to website owners without tracking individual visitors. No cookies, no fingerprinting, no cross-site tracking, no personal data. Every data point is aggregated at the point of collection.

The result is a tool that lets you understand your traffic — where it comes from, which pages perform, what campaigns work — without ever needing a cookie consent banner. That alone is worth the switch for many sites. Your visitors get a cleaner experience, your legal team gets fewer headaches, and you get data that is arguably more accurate than GA4 because it is not missing the 30-40% of visitors who block Google’s scripts.

The Community Edition is the self-hosted version, released under the AGPL v3 license. It includes all the core analytics features. Plausible also offers a paid cloud service starting at $9/month, which funds ongoing development.

Key Features

Single-page dashboard. Everything on one screen: visitors, pageviews, bounce rate, visit duration, top pages, entry pages, exit pages, referral sources, UTM campaigns, countries, regions, cities, devices, browsers, and OS. No clicking through ten different reports.
Custom event tracking. Track button clicks, form submissions, file downloads, outbound links, and any custom interaction. Attach properties to events for segmentation: plausible('Signup', {props: {plan: 'Pro', source: 'homepage'}}).
Funnel analysis. Define multi-step funnels to see where users drop off in conversion flows. Useful for signup flows, checkout processes, and onboarding sequences.
Revenue tracking. Attach monetary values to conversion events for basic e-commerce analytics.
Google Search Console integration. Pull search query, impression, and click-through data directly into your Plausible dashboard. This is something that GA4 makes unnecessarily complicated.
GA data import. Migrate historical data from Universal Analytics or GA4 using the built-in import tool. Your traffic history does not have to start from zero.
Email and Slack reports. Schedule weekly or monthly traffic summaries delivered automatically.
Stats API and Sites API. Programmatic access to all your data. Build custom dashboards, pipe data into spreadsheets, or integrate with other tools.

Installation with Docker

Plausible CE runs on Docker and requires three services: the Plausible application (Elixir), ClickHouse (for analytics event storage), and PostgreSQL (for user accounts and site configuration). The team maintains an official Docker Compose repository.

# Clone the Community Edition hosting repository
git clone https://github.com/plausible/community-edition.git plausible-ce
cd plausible-ce

# Generate required secrets
openssl rand -base64 48  # For SECRET_KEY_BASE
openssl rand -base64 32  # For TOTP_VAULT_KEY

# Configure the instance
cp .env.example .env

Edit the .env file with your settings:

# .env
BASE_URL=https://analytics.yourdomain.com
SECRET_KEY_BASE=your-generated-secret-key
TOTP_VAULT_KEY=your-generated-totp-key
DISABLE_REGISTRATION=invite_only

# Optional: email for account verification and reports
MAILER_EMAIL=analytics@yourdomain.com
SMTP_HOST_ADDR=smtp.yourmailprovider.com
SMTP_HOST_PORT=587
SMTP_USER_NAME=your-smtp-user
SMTP_USER_PWD=your-smtp-password

Start the stack:

docker compose up -d

Create your admin account:

docker compose exec plausible sh -c \
  "bin/plausible createuser --email you@email.com --password yourpassword --name 'Your Name'"

Then add the tracking snippet to your site — it is a single <script> tag that Plausible provides in the dashboard after you add your domain.

Important notes:

Plausible must run on its own subdomain (e.g., analytics.yourdomain.com). Subfolder deployments are not supported.
ClickHouse is the reason for the higher memory requirement. Plan for at least 1 GB of RAM, ideally 2 GB for sites with moderate traffic.
Updates are straightforward: docker compose pull && docker compose up -d.

Privacy and Compliance

Plausible’s privacy model is not an afterthought bolted on top of a tracking tool — it is the foundation the tool was built on.

No cookies of any kind. Not for analytics, not for session tracking, not for anything.
No persistent identifiers. Visitors cannot be tracked across sessions or devices.
IP addresses are used for geolocation at the point of collection and then discarded. They are never stored in the database.
All data is aggregated. There is no way to drill down to an individual visitor’s behavior.
Fully compliant with GDPR, CCPA, and PECR without requiring consent banners.
The company is EU-owned and operated, which matters for EU data sovereignty requirements.

When self-hosted, the tracking script is served from your own domain, making it resistant to ad blockers that target plausible.io. You can also proxy it through your web server to make it indistinguishable from first-party resources.

Resource Usage

Metric	Typical Value
RAM (idle)	800 MB - 1.2 GB
RAM (active, moderate traffic)	1.2 - 2 GB
CPU	Low (Elixir is efficient under load)
Disk	Grows with traffic; ClickHouse compresses well
Containers	3 (Plausible, ClickHouse, PostgreSQL)

The ClickHouse dependency is the main cost. It is overkill for a personal blog but pays off at scale — ClickHouse handles millions of events without breaking a sweat, and dashboard queries return in milliseconds even on large datasets.

Pros

The cleanest, most intuitive analytics dashboard available
Smallest tracking script (< 1 KB) means zero performance impact
No cookie banner needed, period
Revenue tracking and funnel analysis built in
Google Search Console integration and GA data import
Active development with regular releases
Strong community and thorough documentation

Cons

AGPL v3 license, which some organizations have policies against
Higher memory requirements than Umami due to ClickHouse
No heatmaps or session recordings
Less granular than Matomo if you need session-level or individual visitor detail
Cannot run in a subfolder path; requires its own subdomain

Best For

Content sites, blogs, marketing pages, SaaS landing pages, small business websites, and anyone whose primary analytics questions are “how much traffic do I get, where does it come from, and which pages work best.” If you want analytics that are beautiful, fast, and privacy-respecting, Plausible is the gold standard.

2. Umami

Website: umami.is License: MIT GitHub Stars: 24,000+ Written in: Next.js (TypeScript)

Overview

Umami is the minimalist’s analytics tool. The name means “delicious” in Japanese, and the design philosophy matches — strip everything unnecessary, keep what matters, make it fast. Built with Next.js and backed by PostgreSQL (or MySQL), Umami is the platform that developers tend to reach for first because it deploys quickly, uses almost no resources, and gets out of the way.

The MIT license is a significant differentiator. While Plausible uses AGPL v3 (which requires you to open source any modifications you distribute) and Matomo uses GPL v3, Umami’s MIT license imposes no restrictions whatsoever. You can fork it, modify it, embed it in a commercial product, and never share a line of code. For organizations with legal policies against copyleft licenses, this is often the deciding factor.

Umami’s community has grown rapidly, crossing 24,000 GitHub stars and becoming one of the most popular analytics projects on the platform. The team also offers a cloud-hosted version with a free tier for hobby projects.

Key Features

Real-time dashboard. Visitors, pageviews, bounce rate, average visit time, referrers, browsers, OS, device type, countries, and regions — all updating live.
Custom event tracking. Track any user interaction with a clean JavaScript API: umami.track('signup-click', { tier: 'pro', source: 'pricing-page' }).
UTM campaign tracking. Full support for utm_source, utm_medium, utm_campaign, utm_term, and utm_content out of the box.
Multi-site management. Track unlimited websites from a single Umami instance. Each site gets its own dashboard and tracking code.
Team accounts. Create multiple user accounts with different permission levels. Useful for agencies or teams managing multiple client sites.
Custom reports. Filter and segment data by any combination of date range, URL, referrer, country, browser, OS, and device.
Full REST API. Every piece of data in Umami is accessible programmatically. Build custom dashboards, pipe data into Grafana, integrate with CI/CD pipelines, or generate automated reports.
Script and endpoint customization. Rename the tracking script file and the API collection endpoint via environment variables (TRACKER_SCRIPT_NAME, COLLECT_API_ENDPOINT). This is a powerful feature for avoiding ad blockers — if your script is named custom-metrics.js and posts to /api/collect, no generic filter list will catch it.

Installation with Docker

Umami has the simplest Docker setup of any tool in this comparison. Two containers, one command, done.

# docker-compose.yml
version: "3.8"
services:
  umami:
    image: ghcr.io/umami-software/umami:postgresql-latest
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgresql://umami:change-this-password@db:5432/umami
      DATABASE_TYPE: postgresql
      APP_SECRET: replace-with-a-random-string
      TRACKER_SCRIPT_NAME: metrics
      COLLECT_API_ENDPOINT: /api/send
    depends_on:
      db:
        condition: service_healthy
    restart: unless-stopped

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: umami
      POSTGRES_USER: umami
      POSTGRES_PASSWORD: change-this-password
    volumes:
      - ./db-data:/var/lib/postgresql/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U umami"]
      interval: 5s
      timeout: 5s
      retries: 5

docker compose up -d

That is it. Open http://your-server:3000, log in with the default credentials (admin / umami), and change them immediately. Add your first website, grab the tracking snippet, paste it into your site’s <head>, and you are collecting data.

The TRACKER_SCRIPT_NAME and COLLECT_API_ENDPOINT variables in the compose file above rename the tracking script to metrics.js and the collection endpoint to /api/send. This is not just cosmetic — it makes your analytics effectively invisible to ad blockers that rely on pattern matching against known analytics script names and endpoints.

Privacy and Compliance

No cookies used for any purpose.
No personally identifiable information collected.
No cross-site or cross-device tracking.
All visitor data is anonymized at the point of collection.
GDPR compliant by default; no consent banner required.
Respects the Do Not Track (DNT) browser header.
100% of data stays on your server.

Umami’s privacy posture is essentially identical to Plausible’s. Both tools collect only aggregated, non-personal data that does not constitute personal data under GDPR. The practical effect is the same: no cookie banner, no consent flow, no compliance headaches.

Resource Usage

Metric	Typical Value
RAM (idle)	150 - 250 MB
RAM (active, moderate traffic)	250 - 400 MB
CPU	Very low
Disk	Grows modestly; PostgreSQL is efficient
Containers	2 (Umami, PostgreSQL)

This is where Umami genuinely shines. The entire stack — application plus database — runs comfortably in under 500 MB of RAM. You can run it on a $5/month VPS alongside other services without thinking twice. On a homelab mini PC running ten Docker containers, Umami is barely a rounding error in your resource budget.

The difference compared to Plausible is meaningful. Plausible’s ClickHouse dependency adds 600-800 MB of baseline memory. For a personal blog or a small portfolio of sites, that overhead is hard to justify. Umami gives you 90% of the same analytics at 20% of the resource cost.

Pros

MIT license — the most permissive open source license available
Incredibly easy to deploy and maintain (two containers, minimal configuration)
Lowest resource usage of any full-featured analytics tool
Script and endpoint renaming is the best ad-blocker resistance strategy available
Clean, modern UI built with React and Next.js
Full REST API for building custom integrations and dashboards
Active development and rapidly growing community

Cons

No built-in funnel analysis (though you can build this with the API)
No Google Search Console integration
No GA data import tool
No revenue or e-commerce tracking
Reporting depth is shallower than Plausible for some use cases (e.g., no entry/exit pages in the default dashboard)
Smaller plugin and integration ecosystem compared to Matomo

Best For

Developers, indie hackers, small teams, and anyone who values simplicity and resource efficiency above all else. Umami is the right choice if you want analytics that take two minutes to deploy, use almost no resources, and provide a solid REST API for custom workflows. It is also the top pick when MIT licensing is a requirement.

3. Matomo

Website: matomo.org License: GPL v3 GitHub Stars: 20,000+ Written in: PHP

Overview

Matomo is the oldest and most feature-rich self-hosted analytics platform in existence. Originally launched as Piwik in 2007, it rebranded to Matomo in 2018 and has been the default recommendation for organizations that need a true Google Analytics replacement ever since. If you are migrating from GA4 and your team expects to find equivalent functionality — e-commerce tracking, tag management, custom dimensions, heatmaps, session recordings, A/B testing — Matomo is the only self-hosted option that checks every box.

The core platform is free and open source under GPL v3. Advanced features like heatmaps, session recording, A/B testing, and multi-channel conversion attribution are available as premium plugins, sold separately or included in the cloud-hosted version. This freemium model has kept Matomo financially sustainable for nearly two decades, which is something to weigh when evaluating the long-term viability of your analytics stack.

The trade-off is complexity. Matomo is a PHP application backed by MySQL or MariaDB. It has more moving parts than Plausible or Umami, a larger tracking script, higher resource requirements, and a UI that, while functional, shows its age compared to the modern React-based interfaces of newer tools.

Key Features

Full web analytics suite. Pageviews, sessions, users, bounce rate, time on page, entry and exit pages, site speed, and more. Everything you had in Universal Analytics.
E-commerce tracking. Track product views, add-to-cart events, orders, revenue, and abandoned carts. Dedicated e-commerce reports with product and category breakdowns.
Goal and conversion tracking. Define goals based on URLs visited, events triggered, file downloads, or custom conditions. Track conversion rates over time with segmentation.
Funnel analysis (Premium). Multi-step conversion funnels to identify exactly where users drop off. Visualize the path from landing page to conversion.
Heatmaps and session recording (Premium). See where visitors click, how far they scroll, and where they move their mouse. Replay individual sessions to understand behavior. This is a feature that no other self-hosted analytics tool on this list provides natively.
A/B testing (Premium). Run server-side or client-side experiments with statistical significance calculations. No separate experimentation platform needed.
Tag Manager. A built-in tag management system similar to Google Tag Manager. Deploy and manage tracking tags, pixels, and scripts without touching your site’s source code.
Custom dimensions. Add your own metadata to visits and actions for segmentation. Track anything specific to your business logic.
Roll-up reporting. Aggregate data from multiple Matomo instances or sites into a single unified report. Useful for agencies and multi-brand organizations.
Plugin ecosystem. Hundreds of plugins in the Matomo Marketplace — integrations for WordPress, WooCommerce, Shopify, and many more. Community-built and official plugins extend the platform in nearly every direction.
API. Over 200 API endpoints covering every report, segment, and configuration option. If the UI can show it, the API can return it.

Installation with Docker

Matomo runs as a PHP-FPM application paired with a web server (Nginx or Apache) and a MySQL/MariaDB database. The official Docker image is available on Docker Hub.

# docker-compose.yml
version: "3.8"
services:
  matomo-db:
    image: mariadb:11
    container_name: matomo-db
    restart: unless-stopped
    command: --max-allowed-packet=64MB
    volumes:
      - ./db-data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: change-this-root-password
      MYSQL_DATABASE: matomo
      MYSQL_USER: matomo
      MYSQL_PASSWORD: change-this-db-password

  matomo:
    image: matomo:5-fpm-alpine
    container_name: matomo
    restart: unless-stopped
    volumes:
      - ./matomo-data:/var/www/html
    environment:
      MATOMO_DATABASE_HOST: matomo-db
      MATOMO_DATABASE_ADAPTER: mysql
      MATOMO_DATABASE_TABLES_PREFIX: matomo_
      MATOMO_DATABASE_USERNAME: matomo
      MATOMO_DATABASE_PASSWORD: change-this-db-password
      MATOMO_DATABASE_DBNAME: matomo
    depends_on:
      - matomo-db

  matomo-web:
    image: nginx:alpine
    container_name: matomo-web
    restart: unless-stopped
    ports:
      - "8080:80"
    volumes:
      - ./matomo-data:/var/www/html:ro
      - ./matomo-nginx.conf:/etc/nginx/conf.d/default.conf:ro
    depends_on:
      - matomo

You also need an Nginx configuration file. Create matomo-nginx.conf:

upstream php-handler {
    server matomo:9000;
}

server {
    listen 80;
    add_header Referrer-Policy origin always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-Frame-Options "DENY" always;

    root /var/www/html;
    index index.php;

    location ~ ^/(index|matomo|piwik|js/index|plugins/HeatmapSessionRecording/configs)\.php$ {
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        try_files $fastcgi_script_name =404;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;
        fastcgi_param HTTP_PROXY "";
        fastcgi_pass php-handler;
    }

    location ~* ^.+\.php$ {
        deny all;
        return 403;
    }

    location / {
        try_files $uri $uri/ =404;
    }

    location ~ ^/(config|tmp|core|lang) {
        deny all;
        return 403;
    }
}

docker compose up -d

Open http://your-server:8080 and follow the web-based installation wizard. The database host is matomo-db, and the credentials are what you set in the compose file. The wizard walks you through creating an admin account, adding your first website, and getting the tracking code.

Post-installation requirement: Matomo needs a cron job to archive reports. Without it, the dashboard becomes progressively slower as your data grows because it re-queries raw data on every page load.

# Add to your server's crontab (runs every 5 minutes)
*/5 * * * * docker exec matomo php /var/www/html/console core:archive --url=https://analytics.yourdomain.com

This is the kind of operational detail that makes Matomo more demanding to maintain than the other tools. It works well once configured, but you need to know it exists.

Privacy and Compliance

Matomo is privacy-capable but not privacy-by-default in the same way as Plausible or Umami. Out of the box, it uses first-party cookies for session and returning visitor tracking. You can configure it for fully cookieless operation, but this requires explicit setup and disables some features.

Cookieless tracking mode. Configurable in the admin panel. When enabled, no cookies are set, but returning visitor detection and session linking become less accurate.
IP anonymization. Configurable to mask 1, 2, or 3 octets of IP addresses. Set to 2+ octets for GDPR compliance.
Data retention policies. Automatically purge raw log data after a configurable period (e.g., 90 days, 180 days). Aggregated reports are kept indefinitely.
GDPR compliance tools. Built-in features for handling data subject access requests (DSARs), data deletion requests, and consent management.
Opt-out widget. An embeddable iframe that lets visitors opt out of tracking on your site.
Do Not Track support. Configurable respect for the DNT browser header.

The bottom line: Matomo can be configured to be as privacy-friendly as Plausible or Umami, but it requires deliberate effort. If you skip the configuration, you are running analytics with cookies enabled and full IP addresses stored, which means you need a consent banner.

Resource Usage

Metric	Typical Value
RAM (idle)	400 - 700 MB
RAM (active, moderate traffic)	1 - 2.5 GB
CPU	Moderate (PHP is less efficient than Elixir or Next.js for this workload)
Disk	Grows with traffic; MySQL is less space-efficient than ClickHouse
Containers	3 (Matomo PHP-FPM, Nginx, MariaDB)

Matomo is the second heaviest option after PostHog. The PHP + MySQL architecture does not scale as naturally as ClickHouse-backed tools for analytical queries, which is why the archiving cron job exists — it pre-computes reports so the dashboard does not have to crunch raw data on every request.

For a site with under 100,000 pageviews per month, Matomo runs fine on 1-2 GB of RAM. Beyond that, you will want to tune MySQL buffers, ensure the archiving cron runs reliably, and potentially move to a dedicated database server.

Pros

The most feature-complete self-hosted analytics platform available
Closest feature parity with Google Analytics of any tool on this list
Heatmaps, session recordings, and A/B testing (via premium plugins) — features no other self-hosted tool offers
Built-in tag manager eliminates the need for Google Tag Manager
Enormous plugin ecosystem with integrations for WordPress, WooCommerce, Shopify, and more
Over 17 years of development, a large community, and proven sustainability
GA data import tool for migrating historical data
200+ API endpoints for every report and configuration option

Cons

Significantly more complex to deploy and maintain than Plausible or Umami
Requires an archiving cron job for acceptable dashboard performance
Higher resource usage (PHP + MySQL is less efficient for analytics workloads)
The UI feels dated compared to Plausible’s and Umami’s modern interfaces
Tracking script is 22 KB — 22 times larger than Plausible’s
Premium plugins add cost: heatmaps, session recording, and A/B testing each start around $229/year for self-hosted
Cookieless mode requires manual configuration; not private by default
GPL v3 license (copyleft, though less restrictive than AGPL)

Best For

Organizations that need a full Google Analytics replacement with enterprise-grade features. If your requirements include heatmaps, session recordings, A/B testing, e-commerce tracking, tag management, custom dimensions, and roll-up reporting, Matomo is the only self-hosted platform that delivers all of it. It is also the best choice for teams migrating from GA4 who need the transition to feel familiar.

4. PostHog

Website: posthog.com License: MIT (core), with some proprietary enterprise features GitHub Stars: 25,000+ Written in: Python, TypeScript

Overview

PostHog is categorically different from the other three tools in this comparison. Plausible, Umami, and Matomo are web analytics platforms — they answer questions like “how many visitors did my homepage get” and “which referral source drives the most traffic.” PostHog is a product analytics platform — it answers questions like “why do 40% of users abandon onboarding after step 3” and “does the new checkout flow convert better than the old one.”

The difference matters. If you are running a blog, a marketing site, or a portfolio, PostHog is the wrong tool. It is built for teams developing SaaS applications, web apps, and mobile apps where understanding user behavior at the individual and cohort level is critical to product decisions.

PostHog bundles product analytics, session recording, feature flags, A/B testing, surveys, error tracking, and a data warehouse into a single platform. It replaces not just Google Analytics but also Mixpanel, Amplitude, LaunchDarkly, Hotjar, and Statsig. For a startup paying for three or four of those tools, the value proposition is compelling.

The self-hosted “hobby” deployment is free but limited to approximately 100,000 events per month. Beyond that, PostHog nudges you toward their cloud offering, which has a generous free tier (1 million events/month for analytics, 5,000 session recordings/month).

Key Features

Product analytics. Funnels, retention analysis, user paths, trends, stickiness, and lifecycle analysis. Understand not just what pages are viewed but how users flow through your application, where they get stuck, and when they come back.
Session recording. Watch replays of real user sessions. See where they click, scroll, hesitate, and rage-click. Filter recordings by user properties, events, cohorts, or feature flag status. Automatically mask sensitive form inputs and text.
Feature flags. Roll out features to specific percentages of users, target by user properties or cohort membership, and kill features instantly without redeploying. Supports multivariate flags, JSON payloads, and local evaluation for performance.
A/B testing (Experimentation). Run statistically rigorous experiments tied directly to your analytics data. Define primary and secondary metrics, set minimum sample sizes, and get results with confidence intervals.
Surveys. Collect in-app feedback with targeted surveys triggered by user behavior, properties, or events. Multiple question types, customizable appearance, and results integrated into your analytics.
Error tracking. Capture and analyze frontend exceptions alongside analytics data. Correlate errors with user journeys and feature flag states.
Data warehouse. Query your analytics data with SQL. Join PostHog data with data from external sources (Stripe, your production database, etc.) for combined analysis.
Web analytics. A more recent addition. PostHog now includes a traditional web analytics dashboard for pageviews, referrers, and traffic sources, though this is not its primary strength.
SDKs everywhere. Client libraries for JavaScript, React, React Native, Next.js, Python, Ruby, Go, PHP, Node.js, iOS, Android, Flutter, Rust, and more.

Installation with Docker

PostHog’s self-hosted hobby deployment is the heaviest stack in this comparison. It includes the PostHog application, PostgreSQL, ClickHouse, Redis, Kafka, and several worker processes. The team provides a one-line install script:

# Requires Docker and at least 4 GB RAM
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/posthog/posthog/HEAD/bin/deploy-hobby)"

This script downloads the docker-compose.hobby.yml file and walks you through configuring your instance. You will set a SECRET_KEY, your domain name, and email configuration.

If you prefer to set it up manually, here is the gist of what the hobby compose file looks like (simplified — the actual file has more services):

# Simplified view -- use the official hobby compose file
version: "3.8"
services:
  posthog-db:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: posthog
      POSTGRES_DB: posthog
      POSTGRES_PASSWORD: change-this-password
    volumes:
      - ./pg-data:/var/lib/postgresql/data

  posthog-redis:
    image: redis:7-alpine

  posthog-clickhouse:
    image: clickhouse/clickhouse-server:24.3
    volumes:
      - ./clickhouse-data:/var/lib/clickhouse

  posthog-kafka:
    image: bitnami/kafka:3.6
    environment:
      KAFKA_CFG_ZOOKEEPER_CONNECT: posthog-zookeeper:2181

  posthog-zookeeper:
    image: bitnami/zookeeper:3.9
    environment:
      ALLOW_ANONYMOUS_LOGIN: "true"

  posthog-web:
    image: posthog/posthog:latest
    ports:
      - "8000:8000"
    environment:
      DATABASE_URL: postgres://posthog:change-this-password@posthog-db:5432/posthog
      CLICKHOUSE_HOST: posthog-clickhouse
      REDIS_URL: redis://posthog-redis:6379
      KAFKA_HOSTS: posthog-kafka:9092
      SECRET_KEY: your-secret-key
      SITE_URL: https://posthog.yourdomain.com
    depends_on:
      - posthog-db
      - posthog-redis
      - posthog-clickhouse
      - posthog-kafka

After the stack starts, open your PostHog URL and create an admin account through the web interface.

Important caveats about self-hosting PostHog:

The hobby deployment is explicitly limited to ~100,000 events per month. It is meant for evaluation and small projects.
PostHog recommends their cloud offering for production use. The self-hosted hobby version does not receive the same level of support.
Some features (certain data pipeline integrations, some enterprise features) are only available on the cloud version.
Keeping 6+ containers running and updated is meaningfully more operational work than Umami’s two containers.

Privacy and Compliance

PostHog’s privacy posture is fundamentally different from Plausible and Umami. It is a product analytics tool designed to understand individual user behavior, which inherently involves collecting more data.

Cookies by default. PostHog uses cookies for session tracking and user identification. This is a design choice that enables features like session recording and cross-session user journeys.
Cookieless mode. Can be configured with persistence: 'memory' in the SDK configuration. This disables cookies but reduces functionality — session recordings still work but user identification across page loads does not.
Session recording data masking. Automatically masks text inputs, email fields, and other sensitive content in recordings. Configurable via CSS class names.
IP anonymization. Configurable in project settings.
Self-hosted data control. When running on your own infrastructure, all data stays on your servers. No data is sent to PostHog’s cloud.
GDPR compliance. Requires implementation — you will need a consent mechanism if you use cookies (which is the default). PostHog provides documentation for GDPR-compliant setups but does not handle this automatically.

The bottom line: PostHog is not a “drop it in and forget about GDPR” tool. If privacy compliance is your primary motivation for self-hosting analytics, Plausible or Umami are better choices. If you need PostHog’s product analytics capabilities and are willing to implement proper consent flows, it works, but it requires more effort.

Resource Usage

Metric	Typical Value
RAM (idle)	3 - 5 GB
RAM (active, moderate traffic)	5 - 8 GB
CPU	Moderate to high (multiple worker processes)
Disk	Grows significantly with session recordings
Containers	6+ (PostHog, PostgreSQL, ClickHouse, Redis, Kafka, Zookeeper, workers)

PostHog is in a different weight class entirely. Running it on a $5 VPS is not an option. You need a dedicated machine or a VPS with at least 4 GB of RAM, and 8 GB is more realistic for anything beyond evaluation. Session recordings in particular consume significant disk space — a single user session can generate megabytes of recording data.

For context: you could run four or five Umami instances using the resources that a single PostHog hobby deployment consumes.

Pros

The most comprehensive open source product analytics platform available
Session recording, feature flags, A/B testing, and surveys in one tool
Replaces multiple paid SaaS products (Mixpanel, Amplitude, LaunchDarkly, Hotjar, Statsig)
Extremely generous cloud free tier (1M events/month)
Very active development — weekly releases, responsive team
Strong SDK ecosystem covering every major language and framework
SQL data warehouse for advanced analysis
Error tracking integrated with analytics

Cons

Dramatically higher resource requirements than any other tool here (4 GB+ RAM minimum)
Self-hosted hobby version limited to ~100,000 events/month
More complex to deploy, maintain, and update (6+ containers)
Uses cookies by default — not GDPR-compliant out of the box
70 KB tracking script is 70 times larger than Plausible’s
Overkill for simple website traffic analytics
Some features are cloud-only
PostHog is nudging users toward their cloud product; long-term self-hosted support is a valid concern

Best For

Product teams building SaaS applications, web apps, and mobile apps who need deep behavioral analytics, session recordings, feature flags, and experimentation in a single platform. If your questions are “why do users churn after the trial” and “does variant B convert better than variant A,” PostHog is the right tool. If your questions are “how many visitors did my blog get,” it is the wrong tool.

Head-to-Head: Critical Decision Factors

Deployment Complexity

From simplest to most complex:

Umami. Two containers (app + PostgreSQL). One compose file. Two minutes to deploy. Almost nothing can go wrong.
Plausible CE. Three containers (app + ClickHouse + PostgreSQL). Official compose repo with clear documentation. Five minutes to deploy.
Matomo. Three containers (PHP-FPM + Nginx + MariaDB). Requires a separate Nginx config file and a cron job for report archiving. Fifteen minutes to deploy, plus post-setup tuning.
PostHog. Six or more containers (app + PostgreSQL + ClickHouse + Redis + Kafka + Zookeeper + workers). One-line install script helps, but the stack is inherently complex. Thirty minutes to deploy, ongoing maintenance required.

Tracking Script Impact on Page Performance

Your analytics tool should not be the reason your site is slow. Here is how they compare:

Tool	Script Size (gzipped)	External Requests	Impact on Core Web Vitals
Plausible CE	< 1 KB	1 (to your domain)	Negligible
Umami	~2 KB	1 (to your domain)	Negligible
Matomo	~22 KB	1-2 (to your domain)	Minimal
PostHog	~70 KB	2-3 (to your domain)	Noticeable on slow connections
Google Analytics 4	~75 KB	3-5 (to Google)	Significant

Plausible and Umami are effectively invisible in terms of performance impact. Matomo adds a small but measurable overhead. PostHog’s SDK is comparable to Google Analytics because it is doing comparable work (event tracking, session recording initialization, feature flag evaluation).

Tool	Cookies by Default	Can Run Cookieless	Consent Banner Needed
Plausible CE	None	Yes (default)	No
Umami	None	Yes (default)	No
Matomo	Yes (first-party)	Yes (with config)	Yes (unless configured cookieless)
PostHog	Yes (first-party)	Yes (with config)	Yes (unless configured cookieless)

If avoiding consent banners is a priority — and for most website operators it should be, because consent banners reduce engagement and create legal overhead — Plausible and Umami are the clear winners. They achieve this not through a loophole but by genuinely not collecting personal data.

Total Cost of Ownership (Annual)

Assuming you are running on a VPS or homelab, here is the realistic annual cost for each tool.

Cost Factor	Plausible CE	Umami	Matomo	PostHog
Minimum VPS	$5-10/mo (2 GB)	$5/mo (1 GB)	$5-10/mo (2 GB)	$20-40/mo (4-8 GB)
Annual infra cost	$60-120	$60	$60-120	$240-480
Premium plugins	$0	$0	$229-$687+	$0
Maintenance time	Low	Very low	Medium	Medium-high
Total annual	$60-120	$60	$289-807+	$240-480

Umami is the cheapest to run by a wide margin. Plausible is close but needs slightly more memory. Matomo’s premium plugins add up quickly if you need the advanced features. PostHog’s resource appetite makes it the most expensive to self-host, though its cloud free tier is generous enough that many teams will not need to self-host at all.

Recommendations: Which Tool for Which Use Case

After testing all four platforms extensively, here is the decision framework.

Choose Plausible CE if:

You run a blog, content site, marketing site, or SaaS landing page
You want the cleanest and most polished dashboard experience
You need funnel analysis, revenue tracking, or Google Search Console integration
You want to import historical data from Google Analytics
EU data sovereignty matters to your organization
You are comfortable with the AGPL v3 license
You have at least 1-2 GB of RAM available

Plausible is the best all-around analytics tool for websites that are not web applications. Its dashboard is genuinely beautiful, its feature set covers everything most sites need, and its privacy posture eliminates an entire category of legal compliance work.

Choose Umami if:

You are a developer or indie hacker who values simplicity above all
You need the most permissive license possible (MIT)
You want the lowest resource footprint (200 MB RAM)
You plan to build custom dashboards or integrations using the REST API
You want the best ad-blocker resistance (script and endpoint renaming)
You are running on constrained hardware or a cheap VPS
You want to get analytics running in under five minutes

Umami is the tool you reach for when you want analytics that just work, use almost no resources, and get out of your way. It does fewer things than Plausible but does them well, and the MIT license means you will never have a licensing conversation with your legal team.

Choose Matomo if:

You are migrating from Google Analytics and need feature parity
You require heatmaps, session recordings, or A/B testing on a self-hosted platform
You need a built-in tag manager
You have an enterprise environment with complex requirements (multi-site roll-up, custom dimensions, plugin extensibility)
You run an e-commerce site and need detailed product and revenue analytics
You have the infrastructure and team to manage a more complex deployment

Matomo is the enterprise option. It is heavier, more complex, and costs more if you need premium features, but nothing else in the self-hosted world matches its depth. If your CTO asks “can we replace GA4 feature-for-feature with something self-hosted,” the answer is Matomo.

Choose PostHog if:

You are building a SaaS product, web application, or mobile app
You need to understand user behavior at the individual and cohort level
You want session recordings, feature flags, and A/B testing in one platform
You are currently paying for multiple analytics and experimentation tools and want to consolidate
You have the infrastructure for a heavy deployment (4 GB+ RAM)
Your questions are about product usage, not website traffic

PostHog lives in a different category. Do not compare it to Plausible or Umami — they solve different problems. Compare it to the combination of Mixpanel + LaunchDarkly + Hotjar + Statsig. If you are paying for two or more of those, PostHog can replace all of them.

The Pragmatic Default

If you are reading this article and you are still not sure, start with Umami. It deploys in two minutes, uses almost no resources, covers the analytics needs of 90% of websites, and you can always migrate to something else later. Your tracking data starts fresh either way — there is no vendor lock-in with any of these tools.

If you try Umami and find yourself wanting more features — funnel analysis, Search Console data, revenue tracking — move to Plausible CE. The migration is painless because neither tool stores individual visitor data; you are just starting a new aggregate dataset.

Keeping Your Analytics Running

Self-hosted analytics only work if they stay online. Unlike a cloud service where uptime is someone else’s problem, your self-hosted Plausible or Umami instance is your responsibility. If it goes down at 2 AM, you are losing data until you notice and fix it.

Set up monitoring for your analytics endpoint. An uptime monitoring service can check your analytics URL every 60 seconds and alert you via email, Slack, or webhook if it becomes unreachable. For the tools in this article, good health check endpoints include:

Plausible: https://analytics.yourdomain.com/api/health
Umami: https://analytics.yourdomain.com/api/heartbeat
Matomo: https://analytics.yourdomain.com/matomo.php (should return 200)
PostHog: https://posthog.yourdomain.com/_health

Also monitor your database backup scripts. Analytics data that you cannot recover is analytics data that does not exist. Use cron monitoring to ensure your backup jobs complete on schedule — a missed backup is worse than no backup at all, because at least with no backup you know you are unprotected.

Frequently Asked Questions

Can I run these alongside Google Analytics during a transition?

Yes. All four tools use their own independent tracking scripts. You can run Plausible or Umami alongside GA4 during a transition period, compare the data, and remove the GA4 script once you are confident in the self-hosted numbers. This is actually the recommended migration approach.

How accurate are these tools compared to GA4?

Generally more accurate for total visitor counts, because they are not blocked by as many ad blockers. When served from your own domain, self-hosted analytics scripts are treated as first-party resources and pass through most content blockers. Expect to see 20-40% higher visitor numbers than GA4 reports for the same site.

Can I track multiple websites with one instance?

Yes, all four tools support multi-site tracking from a single deployment. Plausible and Umami make this particularly easy — add a new site in the dashboard, get a new tracking snippet, paste it into the site.

What about mobile app analytics?

PostHog has native SDKs for iOS, Android, React Native, and Flutter. It is the only tool in this comparison designed for mobile app analytics. Matomo has mobile SDKs but they are less commonly used. Plausible and Umami are web-only.

How do I handle analytics during deployments?

The analytics service runs independently from your website. Deploying your site does not affect your analytics. If you need to update the analytics service itself, the downtime is typically under 30 seconds for docker compose pull && docker compose up -d. During that window, tracking events are simply lost (they are fire-and-forget HTTP requests from the browser).

Can I export my data from these tools?

Yes. Plausible has a CSV export and a Stats API. Umami has a full REST API and database-level access. Matomo has 200+ API endpoints and supports data export in multiple formats. PostHog has a SQL data warehouse and extensive APIs. In all cases, your data is in a database you control, so you can always query it directly.

Wrapping Up

The self-hosted analytics landscape in 2026 is mature, diverse, and genuinely competitive with commercial offerings. You no longer need to accept Google’s terms to get good analytics, and the privacy benefits of self-hosting are not just philosophical — they have real legal and performance consequences.

Plausible CE gives you a polished, feature-rich dashboard that covers everything most websites need. Umami gives you the simplest, lightest deployment with full API access for custom workflows. Matomo gives you enterprise-grade feature parity with GA4. PostHog gives you a product analytics platform that replaces half a dozen SaaS tools.

All four are free to self-host. All four are actively developed. All four have growing communities. The only question is which one matches your specific needs.

Pick one, deploy it this afternoon, and start owning your analytics data. You will wonder why you did not do it sooner.

Running one of these tools in production? We would love to hear about your setup — which tool, what hardware, how many sites. Your experience helps other self-hosters make better decisions.

Best Self-Hosted Analytics Tools in 2026: Plausible vs Umami vs Matomo vs PostHog

Best Self-Hosted Analytics Tools in 2026: Plausible vs Umami vs Matomo vs PostHog

TL;DR

Quick Comparison Table

1. Plausible Community Edition

Overview

Key Features

Installation with Docker

Privacy and Compliance

Resource Usage

Pros

Cons

Best For

2. Umami

Overview

Key Features

Installation with Docker

Privacy and Compliance

Resource Usage

Pros

Cons

Best For

3. Matomo

Overview

Key Features

Installation with Docker

Privacy and Compliance

Resource Usage

Pros

Cons

Best For

4. PostHog

Overview

Key Features

Installation with Docker

Privacy and Compliance

Resource Usage

Pros

Cons

Best For

Head-to-Head: Critical Decision Factors

Deployment Complexity

Tracking Script Impact on Page Performance

Cookie and Consent Requirements

Total Cost of Ownership (Annual)

Recommendations: Which Tool for Which Use Case

Choose Plausible CE if:

Choose Umami if:

Choose Matomo if:

Choose PostHog if:

The Pragmatic Default

Keeping Your Analytics Running

Frequently Asked Questions

Can I run these alongside Google Analytics during a transition?

How accurate are these tools compared to GA4?

Can I track multiple websites with one instance?

What about mobile app analytics?

How do I handle analytics during deployments?

Can I export my data from these tools?

Wrapping Up