Umami vs GoatCounter: Lightweight Analytics Face-Off

Minimalist Analytics, Two Flavors

Umami and GoatCounter both reject the Google Analytics model. No cookies, no personal data collection, no consent banners needed. Both give you the essentials: pageviews, referrers, devices, and geography. The difference is in how they do it.

Umami is a polished Next.js application with a PostgreSQL backend, team features, and a dashboard that looks like it belongs in a SaaS product.

GoatCounter is a single Go binary that can run on SQLite — so lightweight it uses 25 MB of RAM and serves a tracking script under 3.5 KB.

If you care about looking professional and having room to grow, Umami. If you care about running analytics on a $5/month VPS alongside 10 other services, GoatCounter.

Feature Comparison

Feature	Umami v3.0.3	GoatCounter 2.7
Language	Next.js (Node.js)	Go
Database	PostgreSQL (required)	SQLite or PostgreSQL
Tracking script size	~4 KB	<3.5 KB
Cookie-free	Yes	Yes
GDPR compliant	Yes (no personal data)	Yes (no personal data)
Dashboard	Modern, interactive	Functional, minimal
Multi-site	Yes	Yes
Team accounts	Yes (roles, permissions)	Basic (single admin)
Real-time	Yes	Near real-time
API	REST API	REST API
Custom events	Yes	Yes (basic)
UTM tracking	Yes	Yes
Funnel analysis	Yes (v3+)	No
Retention reports	Yes	No
Goal tracking	Yes	No
Bot filtering	Yes	Yes
Data export	CSV, API	CSV, API
Docker image	ghcr.io/umami-software/umami:v3.0.3	arp242/goatcounter:2.7
License	MIT	EUPL-1.2

Resource Usage

This is where GoatCounter dominates.

Resource	Umami	GoatCounter
RAM (idle)	300-500 MB	20-30 MB
RAM (active, ~1K daily visitors)	500 MB-1 GB	30-50 MB
CPU	Low-moderate	Minimal
Disk (application)	~200 MB (Node.js + deps)	~15 MB (single binary)
External database	PostgreSQL required	SQLite works fine
Minimum VPS	1 GB RAM	256 MB RAM

GoatCounter runs on hardware that Umami can’t. A Raspberry Pi Zero, a $3/month VPS, a shared hosting account — GoatCounter fits wherever there’s 50 MB of RAM to spare.

Dashboard Experience

Umami’s dashboard is visually polished. Interactive charts, date range pickers, comparison periods, and drill-down capabilities. It looks like Plausible’s dashboard (which is a compliment). You can share public dashboards, customize what metrics appear, and use the API to build custom reports.

GoatCounter’s dashboard is utilitarian. Tables of pages, referrers, browsers, and locations. A pageview graph at the top. No interactive drill-downs, no comparison periods, no funnel visualization. It shows you what you need and nothing more.

For a personal blog or small project, GoatCounter’s dashboard is more than sufficient. For a marketing team or client-facing reports, Umami’s presentation is significantly better.

Setup

Umami:

services:
  umami:
    image: ghcr.io/umami-software/umami:v3.0.3
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgresql://umami:your-password@db:5432/umami
      DATABASE_TYPE: postgresql
      APP_SECRET: generate-a-random-32-char-string
    depends_on:
      db:
        condition: service_healthy

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

volumes:
  umami-db:

GoatCounter:

services:
  goatcounter:
    image: arp242/goatcounter:2.7
    restart: unless-stopped
    ports:
      - "8080:8080"
    volumes:
      - goatcounter-data:/data
    command: serve -listen :8080 -tls none -db sqlite3+/data/goatcounter.sqlite3

volumes:
  goatcounter-data:

GoatCounter’s setup is one service, no database container, no environment variables for database credentials. Create your first user from the CLI:

docker exec -it goatcounter goatcounter db create site \
  -vhost stats.yoursite.com -user.email [email protected]

Tracking Script

Both are lightweight and privacy-respecting.

Umami:

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

GoatCounter:

<script data-goatcounter="https://stats.yoursite.com/count"
  async src="//stats.yoursite.com/count.js"></script>

GoatCounter’s script is slightly smaller (~3.5 KB vs ~4 KB) and includes a noscript pixel fallback option for tracking users with JavaScript disabled — a feature Umami lacks.

Scaling

Umami scales with PostgreSQL. For high-traffic sites (100K+ daily visitors), tune the database, add connection pooling (PgBouncer), and increase Node.js memory. The v3 rewrite improved performance significantly.

GoatCounter on SQLite handles up to ~100K pageviews/day comfortably. Beyond that, switch to PostgreSQL. The author (Martin Tournoij) runs it as a hosted service on SQLite for many sites, so the SQLite performance ceiling is higher than most people assume.

FAQ

Which is more accurate?

Comparable. Both count pageviews server-side (via their tracking scripts). Neither uses cookies, so returning visitors are estimated differently. Neither will be as “accurate” as Google Analytics with cookies — that’s the privacy trade-off.

Can I import data from Google Analytics?

Umami supports GA4 data import. GoatCounter has a CSV import feature but no direct GA import.

Do adblockers block these?

Less often than Google Analytics. Self-hosting the tracking script on your own domain (first-party) avoids most adblocker lists. Some privacy-focused blocklists include Umami and GoatCounter by name, but first-party deployment bypasses this.

Which has a better mobile experience?

Umami’s dashboard is responsive and works well on phones. GoatCounter’s dashboard is functional on mobile but optimized for desktop.

Final Verdict

GoatCounter for personal sites and homelabbers. If you want analytics without thinking about database management, memory tuning, or container orchestration, GoatCounter on SQLite is the lightest possible solution. It runs on anything.

Umami for professional sites and teams. If you need polished dashboards, team accounts, funnel analysis, or you’re reporting to stakeholders, Umami’s feature set justifies the PostgreSQL dependency and higher resource usage.

Both respect your visitors’ privacy. The question is whether you need a feature-rich analytics platform or a “just tell me who visited my site” counter.

Related

• How to Self-Host Umami with Docker Compose
• How to Self-Host GoatCounter with Docker
• Plausible vs Umami
• Plausible vs GoatCounter
• Umami vs Matomo
• Best Self-Hosted Analytics Tools
• Replace Google Analytics