<!-- APIScout AI-readable guide source -->
<!-- Canonical: https://apiscout.dev/guides/plausible-vs-umami-vs-fathom-analytics-2026 -->
<!-- Raw Markdown: https://apiscout.dev/guides/plausible-vs-umami-vs-fathom-analytics-2026/raw.md -->
<!-- Source path: content/guides/plausible-vs-umami-vs-fathom-analytics-2026.mdx -->

---
og_image: "/images/guides/plausible-vs-umami-vs-fathom-analytics-2026.webp"
title: "Plausible vs Umami vs Fathom Analytics 2026"
description: "Plausible starts at $9/month for 10K pageviews, open-source and self-hostable. Umami Cloud gives 1M events free per month, MIT-licensed self-hosted in 2026."
date: "2026-03-08"
author: "APIScout Team"
tags: ["web-analytics", "plausible", "umami", "fathom-analytics", "privacy-analytics", "google-analytics-alternative", "gdpr-analytics", "cookieless-analytics"]
---

## Google Analytics 4 Drove Developers Away

Google Analytics 4 launched with a completely redesigned interface, a different data model than Universal Analytics, and a privacy posture that requires cookie consent banners across the EU. For developer blogs, SaaS marketing sites, and small web projects, GA4 became overkill — complex to configure, consent banner required, and far more data collected than most sites need.

The privacy-first analytics market responded. Plausible, Umami, and Fathom all share the same core proposition: cookieless tracking (no consent banner required in most jurisdictions), a simple one-page dashboard with the metrics you actually want, and full GDPR/CCPA compliance by default.

The differences are in pricing model, self-hosting options, feature depth, and philosophical approach to data ownership.

## TL;DR

Plausible is the best all-around choice for most developer-built sites — open-source (AGPL), self-hostable, excellent dashboard, strong funnel and goal tracking, starting at $9/month cloud or free self-hosted. Umami is the right choice for self-hosters who want the most powerful free option — MIT-licensed, unlimited sites, unlimited events, and a feature set that has grown significantly in recent versions. Fathom is the cloud-only premium option for teams that don't want to think about self-hosting — simpler, faster to set up, and unlimited sites on all plans, but more expensive and closed-source.

## Key Takeaways

- **Plausible starts at $9/month** for 10K pageviews/month — AGPL licensed with a self-hostable Community Edition that's free to run yourself.
- **Umami Cloud's free tier includes 1M events/month** — the most generous free tier in the privacy analytics market. Self-hosted Umami (MIT license) is completely free with no event limits.
- **Fathom starts at $15/month** for 100K pageviews across unlimited sites — closed-source, cloud-only, no self-host option.
- **All three are cookieless** — no cookie consent banner required in most EU jurisdictions (verify with your legal team for specific requirements).
- **Plausible is AGPL; Umami is MIT** — the MIT license means you can use Umami commercially and modify it without releasing your changes. AGPL requires releasing changes if you distribute the software.
- **Script size matters for performance**: Plausible's script is ~1KB; Umami's is ~2KB; Fathom's is ~3KB. All are dramatically smaller than Google Analytics (45KB+).
- **Self-hosted Plausible requires more setup** than Umami — Plausible uses PostgreSQL + Clickhouse; Umami uses a single PostgreSQL or MySQL database.

## Pricing Comparison

| Platform | Free Tier | Cloud Paid Starting | Self-Host | Open-Source |
|---------|-----------|---------------------|-----------|-------------|
| Plausible | No (30-day trial) | $9/month (10K PV) | Yes (AGPL) | Yes (AGPL) |
| Umami | Yes (1M events/month) | $9/month (cloud) | Yes (MIT) | Yes (MIT) |
| Fathom | No (trial) | $15/month (100K PV) | No | No |
| Simple Analytics | No | $9/month | No | Partial |
| Matomo | Self-host only | Free (self-host) | Yes | Yes |

## Plausible

**Best for: All-around best cloud option, developer-focused, self-hosting if data ownership matters**

Plausible is the most feature-complete privacy-first analytics tool — goal tracking, funnel analysis, custom event properties, public dashboard option, and a UI that product and marketing teams actually understand. The AGPL license means the source is available, and the Community Edition is self-hostable (though the setup is more involved than Umami).

### Pricing

| Plan | Cost | Pageviews/Month |
|------|------|----------------|
| 10K | $9/month | 10,000 |
| 100K | $19/month | 100,000 |
| 200K | $29/month | 200,000 |
| 1M | $69/month | 1,000,000 |
| 2M+ | Custom | 2M+ |

All plans include unlimited websites, team members, and data retention.

### Installation

```html
<!-- Add to your <head> — ~1KB, no cookies, no consent required -->
<script defer data-domain="yoursite.com"
  src="https://plausible.io/js/script.js">
</script>
```

### Custom Events

```javascript
// Track conversions and custom events
// Using the plausible() function (injected by the script)

// Simple event
plausible("Signup Completed");

// Event with properties
plausible("Plan Upgraded", {
  props: {
    plan: "professional",
    interval: "monthly",
    amount: 29.99,
  },
});

// Outbound link clicks
plausible("Outbound Link: Click", {
  props: { url: "https://github.com/your-org/repo" }
});

// File downloads
document.querySelectorAll("a[href$='.pdf']").forEach(link => {
  link.addEventListener("click", () => {
    plausible("File Download", { props: { file: link.href } });
  });
});
```

### Goals and Funnels

```javascript
// Plausible supports multi-step funnels
// Define goals in the Plausible dashboard:
// Goal 1: Visit /pricing
// Goal 2: Visit /signup
// Goal 3: Custom event "Signup Completed"
// Goal 4: Custom event "Plan Upgraded"

// Plausible shows conversion rates between each step
// No additional code required beyond the event calls above
```

### API Integration

```bash
# Plausible Stats API — pull data programmatically
curl "https://plausible.io/api/v1/stats/aggregate" \
  -H "Authorization: Bearer $PLAUSIBLE_API_KEY" \
  -G \
  -d "site_id=yoursite.com" \
  -d "period=30d" \
  -d "metrics=visitors,pageviews,bounce_rate,visit_duration"

# Response:
# {
#   "results": {
#     "visitors": {"value": 12430},
#     "pageviews": {"value": 28751},
#     "bounce_rate": {"value": 52.3},
#     "visit_duration": {"value": 127}
#   }
# }
```

### Self-Hosting

```yaml
# docker-compose.yml — Plausible self-hosted
version: "3.8"

services:
  plausible_db:
    image: postgres:14
    volumes:
      - db-data:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: password

  plausible_events_db:
    image: clickhouse/clickhouse-server:23.3
    volumes:
      - event-data:/var/lib/clickhouse
      - ./clickhouse-config.xml:/etc/clickhouse-server/config.d/logging.xml:ro

  plausible:
    image: ghcr.io/plausible/community-edition:latest
    command: sh -c "sleep 10 && /entrypoint.sh db createdb && /entrypoint.sh db migrate && /entrypoint.sh run"
    ports:
      - "8000:8000"
    depends_on:
      - plausible_db
      - plausible_events_db
    environment:
      - BASE_URL=https://analytics.yourdomain.com
      - SECRET_KEY_BASE=your-secret-key
      - DATABASE_URL=postgres://postgres:password@plausible_db:5432/plausible_db
      - CLICKHOUSE_DATABASE_URL=http://plausible_events_db:8123/plausible_events_db
```

### When to Choose Plausible

Developer-built sites that need real goal tracking and funnel analysis beyond simple pageview counts, teams that want cloud hosting without managing infrastructure but with the option to self-host later, or organizations where AGPL licensing is acceptable and open-source transparency matters.

## Umami

**Best for: Self-hosters, 1M free events/month cloud, MIT license, multi-site operators**

Umami is the MIT-licensed analytics tool — free to use commercially, free to modify, free to self-host with unlimited sites and unlimited events. The Umami Cloud free tier (1M events/month) is the most generous in the privacy analytics market. Self-hosted Umami requires only a single PostgreSQL or MySQL database — simpler infrastructure than Plausible's dual PostgreSQL + Clickhouse requirement.

### Pricing

| Plan | Cost | Events/Month |
|------|------|-------------|
| Cloud Free | $0 | 1,000,000 |
| Cloud Pro | $9/month | 10,000,000 |
| Self-hosted | Free | Unlimited |

### Installation

```html
<!-- Umami tracking script (~2KB) -->
<script async defer
  src="https://your-umami-instance.com/script.js"
  data-website-id="your-website-id">
</script>
```

### Custom Events

```javascript
// Umami event tracking — using the global umami object
// injected by the tracking script

// Track a simple event
umami.track("button-click");

// Track event with properties
umami.track("plan-upgrade", {
  plan: "professional",
  interval: "monthly",
  amount: 29.99,
});

// Track with custom data
umami.track("search-performed", {
  query: searchQuery,
  results: resultCount,
});

// Identify user (Umami does not track PII — use anonymous IDs)
umami.identify({ userId: hashedUserId });
```

### React/Next.js Integration

```typescript
// useUmami hook for React applications
import { useRouter } from "next/router";
import { useEffect } from "react";

export function usePageTracking() {
  const router = useRouter();

  useEffect(() => {
    const handleRouteChange = (url: string) => {
      if (typeof window !== "undefined" && (window as any).umami) {
        (window as any).umami.track(url);
      }
    };

    router.events.on("routeChangeComplete", handleRouteChange);
    return () => {
      router.events.off("routeChangeComplete", handleRouteChange);
    };
  }, [router.events]);
}
```

### Self-Hosting with Docker

```yaml
# docker-compose.yml — Umami self-hosted (simpler than Plausible)
version: "3.8"

services:
  umami:
    image: ghcr.io/umami-software/umami:postgresql-latest
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgresql://umami:umami@db:5432/umami
      DATABASE_TYPE: postgresql
      APP_SECRET: your-secret-key
    depends_on:
      - db

  db:
    image: postgres:15
    environment:
      POSTGRES_DB: umami
      POSTGRES_USER: umami
      POSTGRES_PASSWORD: umami
    volumes:
      - umami-db-data:/var/lib/postgresql/data

volumes:
  umami-db-data:
```

Umami's self-hosting is significantly simpler than Plausible — a single database, no Clickhouse required.

### Umami API

```bash
# Umami Stats API
curl "https://your-umami.com/api/websites/your-website-id/stats" \
  -H "Authorization: Bearer $UMAMI_API_TOKEN" \
  -G \
  -d "startAt=1672531200000" \
  -d "endAt=1675209600000"

# Response: visitors, pageviews, bounceRate, totalTime
```

### When to Choose Umami

Self-hosters who want the simplest possible setup (single database, MIT license), teams with multiple websites that need unlimited sites at no additional cost, or projects where the 1M events/month free cloud tier eliminates the need for self-hosting at all.

## Fathom Analytics

**Best for: Simplest setup, unlimited sites on all plans, no self-hosting complexity, GDPR by default**

Fathom is the premium cloud-only option — no self-hosting, no open-source version, but the simplest setup experience and unlimited websites included on every plan. Fathom is fully cookie-consent compliant in the EU by design (no cookies set, no personal data collected), which is its core marketing position.

### Pricing

| Plan | Cost | Pageviews/Month | Sites |
|------|------|----------------|-------|
| Starter | $15/month | 100,000 | Unlimited |
| Entrepreneur | $25/month | 200,000 | Unlimited |
| Business | $50/month | 500,000 | Unlimited |
| Enterprise | $90/month | 1,000,000 | Unlimited |

All plans include unlimited sites, team members, and email reports.

### Installation

```html
<!-- Fathom tracking script — ~3KB, cookieless by design -->
<script src="https://cdn.usefathom.com/script.js"
  data-site="ABCDEFGH"
  defer>
</script>
```

### Custom Events

```javascript
// Fathom custom events
// Create goals in the Fathom dashboard first, then track them

// Track a goal
window.fathom.trackEvent("Signup");
window.fathom.trackEvent("Plan Upgraded");
window.fathom.trackEvent("Purchase", { _value: 2999 }); // Value in cents
```

### SPA Tracking (React/Next.js)

```javascript
// Fathom + Next.js router
import { useEffect } from "react";
import { useRouter } from "next/router";
import * as Fathom from "fathom-client";

export default function App({ Component, pageProps }) {
  const router = useRouter();

  useEffect(() => {
    Fathom.load("ABCDEFGH", {
      includedDomains: ["yourdomain.com"],
    });

    function onRouteChangeComplete() {
      Fathom.trackPageview();
    }

    router.events.on("routeChangeComplete", onRouteChangeComplete);
    return () => {
      router.events.off("routeChangeComplete", onRouteChangeComplete);
    };
  }, []);

  return <Component {...pageProps} />;
}
```

### When to Choose Fathom

Teams that want the simplest possible privacy analytics setup (no self-hosting, no infrastructure management), agencies managing analytics for multiple client sites (unlimited sites included), or companies where the closed-source nature is acceptable in exchange for zero operational overhead.

## Feature Comparison

| Feature | Plausible | Umami | Fathom |
|---------|---------|-------|--------|
| Cookieless | Yes | Yes | Yes |
| GDPR compliant | Yes | Yes | Yes |
| Self-hosting | Yes (AGPL) | Yes (MIT) | No |
| Cloud free tier | No (trial) | Yes (1M events) | No (trial) |
| Open-source | Yes (AGPL) | Yes (MIT) | No |
| Custom events | Yes | Yes | Yes (goals) |
| Funnel analysis | Yes | Yes | Limited |
| Public dashboard | Yes | Yes | No |
| API access | Yes | Yes | Yes |
| Multiple sites | Yes (all plans) | Yes (unlimited) | Yes (unlimited) |
| Email reports | Yes | No (self-host) | Yes |
| Real-time data | Yes | Yes | Yes |

## Decision Framework

| Scenario | Recommended |
|----------|-------------|
| Best all-around cloud option | Plausible |
| Best free tier (1M events) | Umami Cloud |
| Self-hosting, MIT license | Umami |
| Multiple sites, no self-hosting | Fathom |
| Self-hosting, want funnels | Plausible |
| GDPR compliance simplest setup | Fathom |
| Developer blog, low traffic | Umami (free) |
| Need API access | Plausible or Umami |
| No technical management | Fathom |

## Verdict

**Plausible** is the best overall cloud choice for developer-built sites — the goal tracking, funnel analysis, and API are the most capable in this comparison, and the $9/month starting price is reasonable. The AGPL license and self-hosting option provide flexibility if data sovereignty becomes a requirement.

**Umami** wins on value — 1M events/month free on cloud, and completely free self-hosted with MIT license and no limits. The infrastructure is simpler to manage than Plausible's, and the feature set has grown substantially in recent versions.

**Fathom** is the right choice when simplicity and no operational overhead are the priorities. Unlimited sites on all plans, the simplest possible setup, and genuine GDPR compliance by design justify the premium ($15/month vs $9/month) for teams that don't want to manage infrastructure or deal with AGPL licensing complexity.


## Self-Hosting Considerations and Data Residency

The choice between cloud-hosted and self-hosted analytics is more than a cost calculation — it has legal, compliance, and operational dimensions that differ across the three platforms.

For teams in the European Union, self-hosting can simplify GDPR compliance. When analytics data stays within your infrastructure and doesn't cross into a third-party's data processing systems, you eliminate data processing agreement requirements and cross-border transfer considerations. Some European legal teams prefer self-hosted analytics specifically because it reduces the number of processors who handle user data.

Plausible offers both a cloud product and open-source self-hosting. The Community Edition is free to self-host but excludes some cloud-only features (shared team access, scheduled email reports). The self-hosted version uses Elixir and ClickHouse — not common stacks for most web teams. Plan for a learning curve or use Plausible's official Docker Compose setup, which handles most of the infrastructure complexity. Plausible's ClickHouse requirement means a minimum of about 2GB RAM for a comfortable deployment.

Umami is the most self-hosting-friendly of the three. It uses Node.js and MySQL or PostgreSQL — common stacks that most backend teams operate comfortably. Railway, Vercel, and Render all have Umami deployment templates that make cloud self-hosting straightforward. Umami is lightweight enough that a $5-10/month VPS handles meaningful traffic volumes. If you want self-hosted analytics with minimal operational overhead, Umami is the practical starting point.

Fathom is cloud-only — it doesn't offer a self-hosted option. Their EU isolation feature (EU data centers, EU company processing) addresses some data residency requirements without self-hosting, but doesn't provide full data sovereignty. If data control is a hard requirement, Fathom isn't the right choice.

Operational overhead for self-hosted analytics: database backups matter more than they seem when you're running your own instance. ClickHouse (for Plausible) has different backup mechanics than PostgreSQL — plan your backup strategy before you need it. Both Plausible and Umami require updates when new versions ship; unlike SaaS, you're responsible for applying security patches and schema migrations. The operational burden is low but non-zero — factor this into the cost comparison with paid cloud plans, especially at small team sizes where infrastructure management competes with product work. For a two-person startup, the $9-19/month for Plausible Cloud or Fathom is often the right trade-off; for a DevOps-savvy team with existing container infrastructure, self-hosting Umami on a $5/month VPS makes the cost comparison clear. The break-even point where self-hosting saves money typically sits around 5-10 sites or 2-3M pageviews per month.

---

Compare privacy-first analytics pricing, features, and GDPR compliance documentation at [APIScout](https://apiscout.dev) — find the right Google Analytics alternative for your site.

*Related: [Best Analytics APIs for Product Teams in 2026](/blog/best-analytics-apis-2026), [How to Add Product Analytics with PostHog](/blog/how-to-add-product-analytics-posthog-2026), [Best A/B Testing APIs (2026)](/blog/best-ab-testing-apis-2026)*