Plausible vs Umami vs Matomo in 2026: Open Source Analytics Compared

TL;DR

Three open source Google Analytics alternatives, three different philosophies. Plausible is the privacy-first, polished option — a sub-1KB script, cookieless by default, and a clean dashboard that shows the 20% of analytics features 80% of people actually use. Umami is the simplest and lightest — MIT license, minimal setup, and a multi-site dashboard without the configuration overhead. Matomo is the full Google Analytics replacement — heatmaps, session recordings, A/B testing, funnel visualization, and 200+ reports with full GDPR compliance. Google Analytics 4 alienated most of its users; these three tools offer clean exits.

Key Takeaways

• Plausible (AGPL-3.0, 21K+ stars) — sub-1KB script, Elixir/ClickHouse, revenue tracking, GSC integration, funnels
• Umami (MIT, 24K+ stars) — Node.js, cleanest dashboard, multi-site, most permissive license, self-host only
• Matomo (GPL-3.0, 20K+ stars) — PHP/MySQL, 200+ reports, heatmaps, session recordings, A/B testing, LDAP
• Google Analytics 4's event-based model confused the majority of its users — a clean break beats relearning GA4
• Plausible and Umami are cookieless by default — no GDPR consent banners required
• Matomo in cookie-free mode also avoids consent requirements but with reduced accuracy

---

The Case Against Google Analytics 4

Google Analytics 4 was a breaking change. Universal Analytics had familiar reports: pageviews, sessions, bounce rate, top pages, referrers. GA4 replaced everything with events, conversions, and Explore reports that require configuration before they show anything useful.

The result: most website owners see less from GA4 than they did from UA, while the tracking footprint is the same size.

The open source analytics space grew substantially as a result. All three tools here offer:

• Privacy-first by default (cookie-free or optional cookies)
• Full data ownership (self-hosted)
• Simpler setup and clearer dashboards
• No Google data sharing

---

Plausible — The Polished Privacy-First Option

Plausible's design philosophy is intentional minimalism. Show the metrics that matter, load fast, and make GDPR compliance automatic.

# Plausible Community Edition docker-compose.yml
# https://github.com/plausible/community-edition
services:
  plausible_db:
    image: postgres:16-alpine
    restart: always
    volumes:
      - db-data:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: postgres

  plausible_events_db:
    image: clickhouse/clickhouse-server:24.3.3.102-alpine
    restart: always
    volumes:
      - event-data:/var/lib/clickhouse
      - event-logs:/var/log/clickhouse-server
      - ./clickhouse/logs.xml:/etc/clickhouse-server/config.d/logs.xml:ro
      - ./clickhouse/ipv4-only.xml:/etc/clickhouse-server/config.d/ipv4-only.xml:ro
    ulimits:
      nofile:
        soft: 262144
        hard: 262144

  plausible:
    image: ghcr.io/plausible/community-edition:v2
    restart: always
    command: sh -c "sleep 10 && /entrypoint.sh db createdb && /entrypoint.sh db migrate && /entrypoint.sh run"
    depends_on:
      - plausible_db
      - plausible_events_db
    ports:
      - 127.0.0.1:8000:8000
    env_file:
      - .env

volumes:
  db-data:
  event-data:
  event-logs:

# .env
BASE_URL=https://analytics.yourdomain.com
SECRET_KEY_BASE=your-64-char-generated-secret
TOTP_VAULT_KEY=your-32-char-generated-key

# SMTP
MAILER_EMAIL=analytics@yourdomain.com
SMTP_HOST_ADDR=smtp.resend.com
SMTP_HOST_PORT=587
SMTP_USER_NAME=resend
SMTP_USER_PWD=re_your_api_key
SMTP_HOST_SSL_ENABLED=true

# Optional: Google Search Console
GOOGLE_CLIENT_ID=your-google-client-id
GOOGLE_CLIENT_SECRET=your-google-secret

What Plausible Tracks

<!-- Basic tracking — under 1KB -->
<script defer data-domain="yourdomain.com"
  src="https://analytics.yourdomain.com/js/script.js"></script>

<!-- Enhanced: outbound links + file downloads + custom events -->
<script defer data-domain="yourdomain.com"
  src="https://analytics.yourdomain.com/js/script.tagged-events.outbound-links.file-downloads.js">
</script>

Custom events and revenue tracking:

// Track a purchase with revenue
window.plausible('Purchase', {
  props: { plan: 'pro' },
  revenue: { currency: 'USD', amount: 49.00 }
});

// Track feature usage
window.plausible('Used Feature X', { props: { source: 'sidebar' } });

// Track sign-up funnel steps
window.plausible('Signup Step', { props: { step: 'email_entered' } });
window.plausible('Signup Step', { props: { step: 'plan_selected' } });
window.plausible('Signup Step', { props: { step: 'payment_complete' } });

Funnel visualization: Plausible's funnels show step-by-step drop-off across any sequence of pages or events — without GA4's event configuration complexity.

Google Search Console integration shows which search queries bring traffic directly in the Plausible dashboard — the only open source analytics tool with native GSC integration.

Key features:

• Sub-1KB script (22x smaller than Matomo)
• Cookieless, no consent banner required by default
• Real-time dashboard
• Custom events with properties
• Revenue tracking and goals
• Funnel visualization
• Google Search Console integration
• Google Analytics import
• Email digests and custom reports
• REST API
• AGPL-3.0 license, 21K+ stars

Infrastructure: Postgres + ClickHouse, ~1–2 GB RAM for moderate traffic

---

Umami — The Minimal MIT Option

Umami is the no-fuss option. Deploy in five minutes, get a clean multi-site dashboard, and never touch configuration again. The MIT license means no copyleft concerns for commercial deployments.

# Umami Docker Compose
services:
  umami:
    image: ghcr.io/umami-software/umami:postgresql-latest
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgresql://umami:password@db:5432/umami
      DATABASE_TYPE: postgresql
      APP_SECRET: your-app-secret-min-32-chars
    depends_on:
      db:
        condition: service_healthy
    restart: always

  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: umami
      POSTGRES_USER: umami
      POSTGRES_PASSWORD: password
    volumes:
      - umami-db-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
      interval: 5s
      timeout: 5s
      retries: 5
    restart: always

volumes:
  umami-db-data:

<!-- Umami tracking script -->
<script defer src="https://analytics.yourdomain.com/script.js"
  data-website-id="your-website-id"></script>

Custom event tracking:

// Track events with data attributes (no JavaScript required)
<button data-umami-event="signup-click" data-umami-event-plan="pro">
  Sign Up
</button>

// Or via JavaScript
window.umami.track('form_submit', { form: 'contact', source: 'header' });

// Track page views manually (for SPAs)
window.umami.track();

Umami's dashboard shows: pageviews, unique visitors, bounce rate, top pages, referrers, devices, browsers, and OS — clean single-page view with date range selector. No configuration required to see these metrics.

Multi-site support: One Umami instance tracks unlimited websites. Each site gets its own tracking script ID. The top-level dashboard shows all sites with aggregate and per-site views.

Key features:

• Cleanest UI of the three tools
• Multi-site from one instance
• Custom event tracking
• Real-time stats
• Team sharing with viewer/admin roles
• REST API
• MIT license — no copyleft concerns
• PostgreSQL or MySQL backend
• 24K+ stars

Infrastructure: Node.js + PostgreSQL, ~256 MB RAM

---

Matomo — The Full Google Analytics Replacement

Matomo is what you choose when you actually need GA's depth: heatmaps, session recordings, A/B tests, detailed e-commerce analytics, and GDPR-compliant enterprise reporting.

# Matomo Docker Compose
services:
  matomo:
    image: matomo:latest
    restart: always
    ports:
      - "8080:80"
    volumes:
      - matomo_data:/var/www/html
    environment:
      MATOMO_DATABASE_HOST: db
      MATOMO_DATABASE_ADAPTER: mysql
      MATOMO_DATABASE_DBNAME: matomo
      MATOMO_DATABASE_USERNAME: matomo
      MATOMO_DATABASE_PASSWORD: password
    depends_on:
      - db

  db:
    image: mariadb:10.11
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: matomo
      MYSQL_USER: matomo
      MYSQL_PASSWORD: password
    volumes:
      - matomo_db:/var/lib/mysql
    command: --max_allowed_packet=64MB

volumes:
  matomo_data:
  matomo_db:

<!-- Matomo tracking code -->
<script>
  var _paq = window._paq = window._paq || [];
  _paq.push(['trackPageView']);
  _paq.push(['enableLinkTracking']);
  (function() {
    var u = "https://analytics.yourdomain.com/";
    _paq.push(['setTrackerUrl', u+'matomo.php']);
    _paq.push(['setSiteId', '1']);
    var d = document, g = d.createElement('script'), s = d.getElementsByTagName('script')[0];
    g.async = true; g.src = u+'matomo.js'; s.parentNode.insertBefore(g, s);
  })();
</script>

Cookie-free mode (no consent banner):

// Disable cookies for GDPR without consent
_paq.push(['disableCookies']);
_paq.push(['trackPageView']);

E-commerce tracking:

// Track product view
_paq.push(['setEcommerceView', 'SKU-001', 'Wireless Headphones', 'Electronics', 79.99]);

// Track add to cart
_paq.push(['addEcommerceItem', 'SKU-001', 'Wireless Headphones', 'Electronics', 79.99, 1]);
_paq.push(['trackEcommerceCartUpdate', 79.99]);

// Track purchase
_paq.push(['addEcommerceItem', 'SKU-001', 'Wireless Headphones', 'Electronics', 79.99, 1]);
_paq.push(['trackEcommerceOrder', 'ORDER-456', 79.99, 79.99, 0, 0, false]);

Heatmaps and session recordings (free plugin) show where users click, scroll, and where they drop off — without sending data to a third-party service like Hotjar.

Key features:

• 200+ reports (channels, devices, geo, behavior, e-commerce)
• Heatmaps and click maps (plugin)
• Session recordings (plugin)
• A/B testing (plugin)
• Funnel visualization
• Goals and conversions
• Segments with complex conditions
• Custom dimensions and variables
• Tag Manager (built-in)
• LDAP/AD and SSO integration
• Scheduled email reports
• GA4 import
• Full REST API
• GPL-3.0 license, 20K+ stars

Infrastructure: PHP/MySQL, ~2–4 GB RAM

---

Full Three-Way Comparison

Feature	Plausible	Umami	Matomo
License	AGPL-3.0	MIT	GPL-3.0
Stars	21K+	24K+	20K+
Stack	Elixir/ClickHouse	Node.js/PostgreSQL	PHP/MySQL
Script size	< 1 KB	< 2 KB	~22 KB
Cookie-free default	✅	✅	Optional
GDPR (no consent)	✅	✅	Cookie-free mode
Real-time	✅	✅	✅
Custom events	✅	✅	✅
Revenue tracking	✅	❌	✅ (detailed)
E-commerce tracking	Basic	❌	✅ Full
Funnels	✅	❌	✅
Heatmaps	❌	❌	✅ (plugin)
Session recordings	❌	❌	✅ (plugin)
A/B testing	❌	❌	✅ (plugin)
Segments	Basic	Basic	✅ Advanced
GA import	✅	❌	✅
GSC integration	✅	❌	❌
LDAP/SSO	❌	Basic	✅
Min RAM	1 GB	256 MB	2 GB
Cloud option	$9–69/mo	Self-host	$23–249/mo

---

Decision Framework

Choose Plausible if:

• You want the best balance of simplicity and useful features
• Revenue tracking and funnels matter but heatmaps don't
• Google Search Console integration adds value
• Cookieless GDPR compliance by default is required
• You want Plausible Cloud as an alternative to self-hosting

Choose Umami if:

• Absolute simplicity is the top priority
• MIT license is required (no copyleft)
• Multiple sites tracked from one dashboard
• Node.js/PostgreSQL stack is simpler for your ops team
• You don't need revenue tracking, funnels, or GSC integration

Choose Matomo if:

• You need Google Analytics-level depth (heatmaps, session recordings, A/B testing)
• Detailed e-commerce analytics (products, cart abandonment, categories)
• Complex segmentation and custom reports
• LDAP/Active Directory or enterprise SSO
• You're migrating from GA4 and want full feature parity
• Scheduled email reports distributed to stakeholders

---

Cost Comparison

Solution	Annual Cost
Google Analytics 360	$150,000+/year
Plausible Cloud (10K pageviews/mo)	$108/year
Plausible Cloud (100K pageviews/mo)	$228/year
Matomo Cloud	$276–2,988/year
Plausible self-hosted	$60–120/year
Umami self-hosted	$60–120/year
Matomo self-hosted	$120–200/year (PHP stack)

---

Data Ownership and GDPR: A Practical Guide

All three tools support GDPR-compliant deployments, but the practical compliance work differs based on whether you're on a cloud plan or self-hosting.

When using Plausible Cloud or Matomo Cloud, your organization is a data controller and the vendor is a data processor. You need a Data Processing Agreement with the vendor (both Plausible and Matomo provide standard DPAs), and the vendor's data center location (EU for both, with appropriate safeguards for other regions) satisfies cross-border transfer requirements under GDPR's adequacy frameworks. The key advantage: neither Plausible nor Umami uses cookies or personal identifiers by default, which means you can deploy their tracking scripts without a cookie consent banner. This is a meaningful UX advantage — cookie banners reduce engagement metrics and create friction for first-time visitors.

When self-hosting any of these tools, data stays entirely on your servers. There's no data processor to contract with, no third-party processing to disclose, and no cross-border transfer concerns (assuming your server is in a jurisdiction appropriate for your visitors). The compliance obligation becomes entirely internal: you need a privacy policy that accurately describes what analytics data you collect, how long you retain it, and how users can request access or deletion. Retention management is your responsibility — all three tools provide APIs or admin interfaces for deleting historical data, but you need to implement retention policies rather than relying on a vendor's default settings.

For visitor data subject requests ("show me my data" or "delete my data"), Plausible and Umami's approach is pragmatic: because they don't store IP addresses or personal identifiers, there's no personal data to export or delete. The analytics records are event counts and aggregate statistics, not individual user records. This de-identification by design makes GDPR subject request handling trivial — there's simply no personal data to find. Matomo, in its full-featured configuration with user IDs and custom dimensions, may store more identifiable data depending on your configuration. If you configure Matomo to capture user IDs or personal attributes, those records require GDPR data subject request handling.

Performance Impact of Analytics Scripts

Page speed affects both user experience and SEO rankings. Understanding the performance impact of each analytics script helps evaluate the real cost of analytics visibility.

Plausible's tracking script is under 1 KB after gzip compression — one of the smallest analytics scripts available. The script loads asynchronously and doesn't block page rendering. The tracking request (a single pixel-equivalent HTTP call) is made after the page loads, adding no perceivable delay to page interactivity. On a mobile connection with high latency, Plausible's script adds approximately 0–5 milliseconds to Time to Interactive. Google's Core Web Vitals methodology specifically evaluates scripts that block rendering or delay interactivity; Plausible's async, minimal script has no detectable impact on these metrics.

Umami's script is under 2 KB — slightly larger than Plausible but still dramatically smaller than Google Analytics. The same async loading pattern applies. Performance impact is negligible for practical purposes.

Matomo's full tracking script is approximately 22 KB (uncompressed) or roughly 7–8 KB gzipped — about 7–8 times larger than Plausible's script. The script includes more functionality (ecommerce tracking, session recording hooks, tag manager integration), which justifies the size. For sites where Core Web Vitals scores are a performance priority, Matomo's script weight is worth evaluating. Matomo's disableCookies and minimal tracking mode reduce functionality but not significantly reduce script size — the functionality is loaded regardless, just not all of it is used. For performance-critical applications (landing pages with sub-second load time requirements, progressive web apps optimizing every byte), Plausible or Umami's scripts are meaningfully better choices.

---

For most self-hosted deployments (under 5 million pageviews/month), the script size difference between Plausible and Matomo has negligible real-world impact in practice — both load asynchronously and both score well on Lighthouse performance audits. The choice between them should be driven by feature requirements, not script weight. Script size becomes a meaningful differentiator only for publishers or marketers who are obsessively optimizing every millisecond of page load — a smaller audience, but one where Plausible's sub-1-KB script is a genuine technical advantage over Matomo's 22 KB.

Related: Plausible vs Umami · Matomo vs Plausible: Full-Featured vs Lightweight · Self-Hosting Guide: Deploy Plausible Analytics

See open source alternatives to Plausible on OSSAlt.