Self-Hosted Analytics Comparison
Why Self-Host Your Analytics?
Google Analytics is free because you are the product. Every pageview, scroll depth, and conversion event feeds Google’s ad targeting machine. Self-hosted analytics gives you full ownership of your traffic data, zero third-party tracking, and — in most cases — a cleaner, faster dashboard than GA4’s labyrinthine interface.
But “self-hosted analytics” is not one tool. There are 11+ serious options, and they solve different problems. This guide compares all of them so you can pick the right one without deploying five different stacks first.
If you just want to ditch Google Analytics entirely, see Self-Hosted Alternatives to Google Analytics.
Prerequisites
- Familiarity with Docker Compose (all tools below run in Docker)
- A Linux server with at least 1 GB RAM (some tools need more — see the comparison table)
- A domain name for accessing your dashboard remotely
- A reverse proxy for SSL termination
No Docker Compose configs in this guide — each tool’s dedicated setup guide has the full stack. This guide is about choosing the right tool.
The Landscape at a Glance
Self-hosted analytics tools fall into three categories:
-
Simple web analytics — page views, referrers, top pages. Lightweight, privacy-first, cookie-free. Replaces GA for content sites. Examples: Plausible, Umami, GoatCounter, Fathom Lite, Ackee, Shynet.
-
Full web analytics — everything above plus goals, funnels, segmentation, custom dimensions, heatmaps. Replaces GA4 feature-for-feature. Examples: Matomo, Open Web Analytics, Countly.
-
Product analytics — event tracking, user identification, session replays, feature flags, A/B testing. Replaces Mixpanel/Amplitude. Examples: PostHog.
GoAccess is the outlier — it parses server access logs directly, requires no JavaScript snippet, and runs as a terminal application or static HTML report.
Comprehensive Comparison Table
| Plausible | Umami | Matomo | PostHog | GoAccess | Ackee | GoatCounter | Fathom Lite | Shynet | Open Web Analytics | Countly | |
|---|---|---|---|---|---|---|---|---|---|---|---|
| License | AGPL-3.0 | MIT | GPL-3.0 | MIT (self-host) | MIT | MIT | EUPL-1.2 | MIT | Apache-2.0 | GPL-2.0 | AGPL-3.0 |
| Language | Elixir | Next.js (Node) | PHP | Python/TS | C | Node.js | Go | Go | Python (Django) | PHP | Node.js |
| Database | ClickHouse + PostgreSQL | PostgreSQL or MySQL | MySQL or MariaDB | ClickHouse + PostgreSQL | None (reads log files) | MongoDB | PostgreSQL or SQLite | SQLite | PostgreSQL | MySQL | MongoDB |
| Tracking method | JS snippet | JS snippet | JS snippet | JS snippet | Server log parsing | JS snippet | JS snippet (or pixel) | JS snippet | JS pixel (no-JS capable) | JS snippet | JS SDK |
| Script size | ~1 KB | ~2 KB | ~22 KB | ~70 KB | N/A (no script) | ~1.5 KB | ~3.5 KB | ~1.5 KB | N/A (pixel) | ~75 KB | ~50 KB |
| Cookie-free | Yes | Yes | Optional (yes by default in recent versions) | No (uses cookies) | N/A | Yes | Yes | Yes | Yes | No | No |
| GDPR-friendly | Yes — no consent banner needed | Yes — no consent banner needed | Yes if configured correctly | Requires consent | Yes — no JS, no cookies | Yes — no consent needed | Yes — no consent needed | Yes — no consent needed | Yes — no consent needed | Requires consent | Requires consent |
| Dashboard | Single page, real-time | Multi-page, real-time | Complex, GA-style | Complex, product-focused | Terminal or static HTML | Single page, minimal | Single page, simple | Single page, minimal | Multi-page, detailed | GA-style | Complex, multi-view |
| Custom events | Yes | Yes | Yes | Yes (core feature) | No | No | Limited | No | No | Yes | Yes (core feature) |
| Funnels | Yes (paid cloud; CE basic) | No | Yes | Yes (core feature) | No | No | No | No | No | Yes | Yes |
| Session replays | No | No | Yes (plugin) | Yes (core feature) | No | No | No | No | No | No | No |
| API | Yes (REST) | Yes (REST) | Yes (REST) | Yes (REST) | JSON output | Yes (GraphQL) | Yes (REST) | No | Yes (REST) | Yes (REST) | Yes (REST) |
| Mobile analytics | No | No | Yes (SDK) | Yes (SDK) | No | No | No | No | No | No | Yes (SDK) |
| Import from GA | Yes | No | Yes | No | No | No | Yes (CSV) | No | No | No | No |
| RAM usage (idle) | ~500 MB (ClickHouse) | ~150 MB | ~256 MB | ~1 GB+ (ClickHouse) | ~10 MB | ~100 MB | ~30 MB | ~20 MB | ~150 MB | ~200 MB | ~400 MB |
| Best for | Content sites, blogs, SaaS marketing pages | Content sites, multi-site tracking | GA replacement with full feature parity | SaaS product analytics, startups | Server operators who avoid JS, bandwidth analysis | Minimal privacy-first tracking | Personal sites, blogs, small projects | Minimal single-site tracking | Pixel-based privacy tracking | Legacy PHP environments | Mobile + web product analytics |
| Actively maintained | Yes | Yes | Yes | Yes | Yes | Low activity | Yes | No (archived) | Low activity | Low activity | Yes |
Decision Tree
Stop reading the table. Here is what you should actually deploy:
If you run a content site, blog, or marketing page
Use Plausible. It is the best balance of useful data, minimal resource usage, privacy compliance, and active development. The single-page dashboard shows everything you need — top pages, referrers, countries, devices — without clicking through five menus. No cookies, no consent banner, GDPR-compliant by default.
If Plausible’s ClickHouse dependency bothers you (it needs ~500 MB RAM), use Umami instead. Nearly identical feature set, runs on PostgreSQL alone, lower RAM footprint (~150 MB). The trade-off: Umami’s dashboard requires more clicks to get the same information, and it lacks GA import.
For a detailed head-to-head, see Plausible vs Umami.
If you need Google Analytics feature parity
Use Matomo. It is the only self-hosted tool with funnels, segmentation, custom dimensions, heatmaps (via plugin), session recording (via plugin), and a GA data importer. If your marketing team is used to GA and will revolt without similar depth, Matomo is the answer.
The cost: Matomo’s interface is complex, its PHP codebase is heavy, and the tracking script is 22 KB. See Plausible vs Matomo and Umami vs Matomo for trade-off details.
If you need product analytics (events, funnels, session replays, feature flags)
Use PostHog. It is not a web analytics tool — it is a product analytics platform. Event tracking, user identification, session replays, feature flags, A/B experiments, all self-hosted. PostHog replaces Mixpanel, Amplitude, and LaunchDarkly in one stack.
The cost: PostHog is resource-heavy (ClickHouse + PostgreSQL + Redis + multiple services). Plan for 2 GB+ RAM minimum. It also uses cookies and requires a consent banner under GDPR.
For the distinction between web and product analytics, see Matomo vs PostHog.
If you refuse to run JavaScript on your site
Use GoAccess. It parses Nginx, Apache, or Caddy access logs directly. Zero JavaScript, zero cookies, zero tracking pixels. It runs in the terminal or generates a static HTML report. Ideal for server operators who want traffic visibility without modifying their site.
The trade-off: no real-time dashboard (unless you use the WebSocket mode), no referrer detail beyond what the HTTP Referer header provides, no custom events.
If you want the absolute lightest option
Use GoatCounter. A single Go binary with SQLite, ~30 MB RAM, minimal JS snippet. No cookies, GDPR-compliant, actively maintained. Perfect for personal sites and small projects where Plausible’s ClickHouse dependency is overkill.
If you track mobile apps alongside web
Use Countly or PostHog. Both have native mobile SDKs (iOS and Android). Matomo also has mobile SDKs but they are less polished. None of the lightweight tools (Plausible, Umami, GoatCounter) support mobile app tracking.
Tools to avoid for new deployments
Fathom Lite — archived by its maintainers. The commercial Fathom product is cloud-only now. The open-source Lite version works but receives no updates.
Ackee — development has slowed significantly. It also requires MongoDB, which is unusual overhead for a minimal analytics tool.
Shynet — clever pixel-based approach but low commit activity. Fine if you specifically need no-JS tracking; otherwise Plausible or GoatCounter are better maintained.
Open Web Analytics — still PHP 7.x era. Functional but dated. Use Matomo if you need a full-featured PHP analytics stack.
Resource Requirements Summary
For capacity planning on your server:
| Tool | Minimum RAM | Database overhead | Suitable for shared server? |
|---|---|---|---|
| GoatCounter | 64 MB | SQLite (none) | Yes |
| Fathom Lite | 64 MB | SQLite (none) | Yes |
| GoAccess | 32 MB | None | Yes |
| Ackee | 256 MB | MongoDB (~200 MB) | Marginal |
| Shynet | 256 MB | PostgreSQL (~100 MB) | Marginal |
| Umami | 256 MB | PostgreSQL (~100 MB) | Yes |
| Matomo | 512 MB | MySQL/MariaDB (~200 MB) | Marginal |
| Open Web Analytics | 256 MB | MySQL (~200 MB) | Marginal |
| Plausible | 768 MB | ClickHouse + PostgreSQL (~500 MB) | No — give it its own resources |
| Countly | 1 GB | MongoDB (~400 MB) | No |
| PostHog | 2 GB+ | ClickHouse + PostgreSQL + Redis | No — dedicated server recommended |
If you are running analytics alongside 10 other services on a single mini PC, GoatCounter, Umami, or GoAccess are the practical choices.
Privacy and Compliance
Every analytics tool collects some data. Here is what matters for GDPR, CCPA, and ePrivacy compliance:
No consent banner needed (cookie-free, no personal data stored): Plausible, Umami, GoatCounter, Fathom Lite, Ackee, Shynet, GoAccess.
Consent banner recommended (uses cookies or stores personal identifiers): Matomo (configurable — can be cookie-free), PostHog, Open Web Analytics, Countly.
If eliminating consent banners entirely is a priority, your shortlist is Plausible, Umami, or GoatCounter.
Migration Path from Google Analytics
If you have historical GA data you want to preserve:
- Plausible — has a built-in Google Analytics importer (both UA and GA4)
- Matomo — has a Google Analytics importer plugin
- GoatCounter — accepts CSV imports (manual formatting required)
- All others — no import path; you start fresh
For most sites, starting fresh is fine. Historical GA data loses value quickly, and the metrics are not directly comparable between platforms anyway.
Common Mistakes
Deploying PostHog when you need page view counts. PostHog is a product analytics platform. If you just want to know which blog posts get traffic, you are deploying a semi-truck to carry a grocery bag. Use Plausible or Umami.
Choosing Matomo “just in case” you need advanced features later. Matomo’s operational overhead (PHP, MySQL, cron jobs for report archival) is significantly higher than Plausible or Umami. If you are not using funnels, segmentation, or custom dimensions today, start simple and migrate later if needed.
Ignoring ClickHouse’s memory requirements. Both Plausible and PostHog use ClickHouse, which is memory-hungry. On a 1 GB VPS, ClickHouse will OOM-kill your other services. Plan for 2 GB minimum if running Plausible alongside other apps, 4 GB if running PostHog.
Running multiple analytics tools simultaneously. Each JS snippet adds page weight and tracking overhead. Pick one. If you want log-based analysis alongside JS analytics, GoAccess is the only one that adds zero page weight since it reads server logs.
Next Steps
Pick your tool based on the decision tree above, then follow the dedicated setup guide:
- Self-Host Plausible — recommended for most sites
- Self-Host Umami — lightweight alternative to Plausible
- Self-Host Matomo — full GA replacement
- Self-Host PostHog — product analytics
- Self-Host GoAccess — server log analysis
Once deployed, add the tracking snippet to your site’s <head> tag (or configure log parsing for GoAccess) and verify data is flowing within minutes.
Related
- Best Self-Hosted Analytics
- Self-Hosted Alternatives to Google Analytics
- How to Self-Host Plausible
- How to Self-Host Umami
- How to Self-Host Matomo
- How to Self-Host PostHog
- How to Self-Host GoAccess
- How to Self-Host Ackee
- How to Self-Host GoatCounter
- How to Self-Host Fathom Lite
- How to Self-Host Shynet
- How to Self-Host Open Web Analytics
- How to Self-Host Countly
- Plausible vs Umami
- Plausible vs Matomo
- Umami vs Matomo
- Matomo vs PostHog
- Docker Compose Basics
- Reverse Proxy Setup
Get self-hosting tips in your inbox
Get the Docker Compose configs, hardware picks, and setup shortcuts we don't put in articles. Weekly. No spam.
Comments