Self-host Plausible on Netcup — privacy-first analytics in the EU

TL;DR: Running Plausible on Netcup in 5 minutes

Self-host Plausible on a Netcup VPS to keep visitor data out of Google Analytics, off Cloudflare's network, and inside the EU jurisdiction the regulator already trusts. Plausible Community Edition is the open-source, cookieless Google Analytics alternative built on Elixir, Phoenix, PostgreSQL, and ClickHouse — the heaviest of those four is ClickHouse, which is why this is not a 512 MB shoebox project.

• What it is: a cookieless, single-page analytics dashboard with a 1 KB tracker script.
• Competes with: Google Analytics 4, Matomo, Cloudflare Web Analytics, Fathom, Umami.
• Hosting profile: 2 GB RAM minimum per the official docs, 4–8 GB comfortable for any real traffic.
• CPU requirement: SSE 4.2 (x86) or NEON (ARM) — every modern Netcup tier qualifies.
• License: AGPLv3 for the analytics core, MIT for the tracker script.
• Latest stable: v3.2.0, released January 26, 2026, by Plausible Insights OÜ in Estonia.

Install on a fresh Debian 12 box:

git clone -b v3.2.0 https://github.com/plausible/community-edition.git plausible-ce
cd plausible-ce
echo "BASE_URL=https://stats.example.com" > .env
echo "SECRET_KEY_BASE=$(openssl rand -base64 48)" >> .env
docker compose up -d

Primary pick: VPS 1000 G12 — 4 vCore, 8 GB DDR5 ECC, 256 GB NVMe, around €10.37/month. ClickHouse, PostgreSQL, and the BEAM VM cohabit comfortably here without swapping when traffic spikes.

• First month free: 5799nc17800061381
• Second code: 5799nc17774618550
• Third code: 5799nc17800061380

Introduction

Most teams reach for Google Analytics because it is free, then spend the next two years arguing with their privacy lawyer about the cookie banner, the IP-anonymisation flag, and whether GA4's "events" actually answer the questions GA3's "pageviews" did. The Schrems II ruling did not help — every German DPA has a slightly different opinion on whether GA in its default configuration is even legal to use, and the answer keeps moving. Plausible sidesteps the entire conversation: no cookies, no persistent identifiers, no cross-site tracking, no consent banner needed in most jurisdictions.

The hosted version starts at 9 USD per month for 10,000 monthly pageviews. That is a fair deal for a small site, but it scales linearly with traffic — and the data still flows through someone else's servers, which is precisely the thing you were trying to fix when you migrated off Google. Plausible Community Edition takes the same Elixir codebase, removes a few cloud-specific premium features, and ships it as a Docker Compose stack you can run on hardware you control.

A Netcup VPS lines up unusually well with this workload. The data centres are in Nuremberg, Karlsruhe, and Vienna — squarely inside the EU, with German privacy law as the default backstop. NVMe is included on every tier, which matters because ClickHouse is happiest on fast storage. The price-per-gigabyte of RAM is the cheapest of any reputable European host, which matters because ClickHouse is also happiest with plenty of RAM. The DPA paperwork is trivially in German, which matters if the site you are measuring is in German.

By the end of this article you will have a working self-hosted Plausible instance behind HTTPS, a sense of which Netcup tier matches the size of the site you intend to track, and a backup story that survives a host reboot.

What is Plausible?

Plausible Analytics is a lightweight, cookie-free web analytics product that replaces Google Analytics for site owners who want the numbers without the surveillance. The tracker script is roughly 1 KB on the wire — about 54 times smaller than the GA4 tag — and the dashboard fits on a single page. Bounce rate, top pages, top referrers, country breakdown, conversions, and goals are the core metrics; there is no fifteen-tab "Explore" section to learn.

Architecture

Plausible CE is shipped as three Docker containers and a compose file:

• plausible — the application server, running on Elixir 1.x with Phoenix. This is where the dashboard renders, the API answers, and the ingest endpoint accepts pageview pings. The image is ghcr.io/plausible/community-edition:v3.2.0.
• plausible_db — PostgreSQL 16 (Alpine). Stores users, sites, goals, and the billing-adjacent metadata. Tiny on disk; rarely the bottleneck.
• plausible_events_db — ClickHouse 24.12 (Alpine). Stores every pageview as a row in a columnar table. This is where the bulk of disk and RAM goes, and the reason 2 GB is a floor rather than a ceiling.

The container exposes HTTP on port 80 and HTTPS on port 443 by default, with built-in Let's Encrypt support. There is also a "behind-a-reverse-proxy" mode where you turn off the embedded TLS and let Caddy or Nginx handle the certificate — generally the cleaner path on a multi-service VPS.

Who maintains it

Plausible Insights OÜ is an Estonian company that has been bootstrapped and profitable since 2020. The same team writes the cloud version and the CE codebase; the CE branch ships on a roughly biannual cadence and lags the cloud version on premium features (advanced funnels, native Google Search Console integration, team-management UI). The repo on GitHub has 24.8k stars and is actively maintained. v3.2.0 (January 26, 2026) is the current release.

License

The analytics application is AGPLv3. The 1 KB tracker script is MIT — that distinction matters because the script is what hits your visitors' browsers, and MIT means you can ship it from your own CDN without any attribution drama. AGPLv3 on the server side is the lever that keeps a hypothetical "Plausible-as-a-service-clone" from showing up tomorrow without contributing back; for self-hosters it has no practical effect, since serving your own pages is not "distribution" of the analytics software.

Cloud vs. Community Edition

Plausible Cloud and Plausible CE share the same codebase but not the same release cadence or feature set. The cloud version gets continuous deployments and includes premium features that need ongoing operational work — managed bot filtering with a real threat-intel feed, native Google Search Console connector, a billing UI. CE ships with the basics: the dashboard, goals and conversions, custom properties, the API, single-sign-on via Google OAuth (optional), and a simpler bot filter. For 99 percent of use cases — measuring a marketing site, a SaaS landing page, a portfolio, a documentation site — the CE feature set is identical to what you actually use on the hosted plan.

How to use Plausible

Plausible is designed to be the analytics tool you check once a week, not a dashboard you live inside. The vocabulary is small on purpose.

Core concepts

• Site: one tracked domain (or a group of subdomains rolled up). Each site gets its own dashboard and tracker snippet.
• Visitor: a unique device-day. Plausible identifies visitors with a daily-rotating hash of IP plus User-Agent plus a daily salt — the salt rotates at midnight UTC, so the same person tomorrow is a fresh visitor. No cookie, no fingerprint persistence.
• Pageview: every page load with the script on it. The most basic event.
• Goal: a named outcome. Two flavours: a URL-pattern match (/signup/success) or a custom-event name fired by JavaScript (plausible('Signup')).
• Custom property: optional key-value tags attached to events. Useful for slicing by plan tier, locale, or A/B variant without polluting the URL.
• Funnel: a sequence of goals, charted as a drop-off. CE supports basic funnels; the cloud has the deeper analysis variants.

Day-to-day workflow

Add a site, paste the script tag into the <head> of your pages (or use the WordPress plugin, or the npm package, or the GTM template), wait an hour, and visitors start showing up on the dashboard. Configure goals next — usually a "thanks for signing up" URL and one or two custom events. After that the rhythm is: weekly glance at the trend, monthly export of the data via the Stats API for whatever spreadsheet your CFO insists on, and otherwise nothing. The tool does not demand your attention.

Integrations and extensibility

Plausible exposes two HTTP APIs: a write-side Events API for sending pageviews from a server (useful for SSR frameworks where the JS tracker is awkward) and a read-side Stats API that returns aggregates as JSON. Both are documented and stable. The Stats API is what grafana-plausible-datasource, plausible-cli, and a dozen Hugo and Astro themes use to embed live numbers in pages.

There is no plugin system. The AGPL license and the small Elixir codebase make forks practical when you genuinely need a feature CE will not ship — but for almost every customisation people imagine, a small wrapper around the Stats API is the cleaner answer.

Backup and operational reality

Three things matter for a Plausible backup:

1. The PostgreSQL volume (plausible_db_data). Small (megabytes to a couple of gigabytes), but losing it means losing your goals, your users, and your site configuration. Daily pg_dump is enough.
2. The ClickHouse volume (plausible_events_data). This is the one with all the pageviews. ClickHouse has its own backup tools (clickhouse-backup); a filesystem snapshot of a stopped container also works for a small instance.
3. The .env file — specifically the SECRET_KEY_BASE. If you rotate this, every existing session and signed URL is invalidated. Keep it somewhere you can find it.

Pageview data is append-only, so the backup window for ClickHouse can be generous — a daily snapshot of the previous day's data plus a weekly full is fine. PostgreSQL deserves the standard daily-dump treatment.

Quick Start Guide

Six steps from a freshly provisioned Netcup VPS to a working Plausible instance behind HTTPS, with daily backups.

1. Provision the box

Sign up for the VPS 1000 G12 at netcup.com using coupon 5799nc17804382700 for one free month. Pick Debian 12 as the image, paste in your SSH public key, and skip the password option entirely. SSH in as soon as the VPS finishes provisioning, then harden the daemon:

# /etc/ssh/sshd_config.d/00-hardening.conf
PasswordAuthentication no
PermitRootLogin prohibit-password
KbdInteractiveAuthentication no

ufw default deny incoming
ufw default allow outgoing
ufw allow 22/tcp
ufw allow 80/tcp
ufw allow 443/tcp
ufw enable

Restart sshd, reconnect in a second terminal to confirm key auth still works, then close the original session. Standard hygiene.

2. Install Docker

Plausible CE is shipped only as Docker Compose. Pull the upstream Docker installer rather than the Debian-packaged version — Debian 12's docker.io is old enough to miss the compose v2 features the Plausible compose file uses.

curl -fsSL https://get.docker.com | sh
systemctl enable --now docker
docker compose version

docker compose version should print v2.20 or newer. Anything older predates the depends_on.condition: service_healthy syntax that Plausible's compose relies on, and the stack will refuse to start cleanly.

3. Clone and configure Plausible CE

Pin the clone to a release tag rather than master. Master can move under you between visits.

git clone -b v3.2.0 https://github.com/plausible/community-edition.git /opt/plausible-ce
cd /opt/plausible-ce

Create the .env file:

# /opt/plausible-ce/.env
BASE_URL=https://stats.example.com
SECRET_KEY_BASE=<paste output of: openssl rand -base64 48>
DISABLE_REGISTRATION=invite_only

BASE_URL must match the public hostname you will reach the instance at. SECRET_KEY_BASE must be at least 64 bytes (the openssl rand -base64 48 output is 64 base64 characters). DISABLE_REGISTRATION=invite_only keeps the world from creating accounts on your instance — you log in once, create the admin, and the public registration form goes away.

4. Start the stack

The default compose does not expose ports to the host — that is intentional, since most production setups run a reverse proxy. Add a small override file for the reverse-proxy path:

# /opt/plausible-ce/compose.override.yml
services:
  plausible:
    ports:
      - "127.0.0.1:8000:8000"

Then bring it up:

docker compose up -d
docker compose ps
docker compose logs -f plausible

Watch the logs for the Running PlausibleWeb.Endpoint with Bandit line — that is the application announcing it is ready. ClickHouse takes a few seconds longer than the others to settle on first boot; if the plausible container restarts once or twice waiting for it, that is expected.

5. Put Caddy in front

Caddy is the easiest HTTPS terminator on a single-app VPS. It fetches a Let's Encrypt certificate the first time a request arrives, renews automatically, and the entire config fits in three lines.

apt install -y debian-keyring debian-archive-keyring apt-transport-https curl
curl -fsSL 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | gpg --dearmor -o /usr/share/keyrings/caddy-stable.gpg
echo "deb [signed-by=/usr/share/keyrings/caddy-stable.gpg] https://dl.cloudsmith.io/public/caddy/stable/deb/debian any-version main" > /etc/apt/sources.list.d/caddy-stable.list
apt update && apt install -y caddy

Replace /etc/caddy/Caddyfile with:

stats.example.com {
    reverse_proxy 127.0.0.1:8000
    encode zstd gzip
}

Reload Caddy: systemctl reload caddy. Within a minute the cert is provisioned and https://stats.example.com returns the Plausible login page.

6. First user, first site, first pageview

Open https://stats.example.com/register and create the first account. Because DISABLE_REGISTRATION=invite_only is set, the form appears once for this initial admin and then vanishes for the public — invited users still get in via email links.

Add a site, copy the tracker snippet, paste it into the <head> of your pages. Open one of those pages in a private browser window, then refresh the Plausible dashboard. The pageview appears in real time.

For backups, drop a pg_dump line into cron:

# /etc/cron.daily/plausible-db-backup
#!/bin/sh
set -e
mkdir -p /srv/plausible-backups
docker exec plausible-ce-plausible_db-1 pg_dump -U postgres plausible_db \
  | gzip > /srv/plausible-backups/pg-$(date +\%F).sql.gz
find /srv/plausible-backups -name 'pg-*.sql.gz' -mtime +14 -delete

chmod +x and you have a 14-day rolling Postgres backup. For ClickHouse, pull the official clickhouse-backup image on the same schedule, or use a filesystem-level snapshot of /var/lib/docker/volumes/plausible-ce_event-data while the stack is briefly stopped.

Choosing the Right Netcup Server for cheap Plausible hosting

Plausible's resource curve is dominated by ClickHouse. The application server itself idles at a couple of hundred megabytes, PostgreSQL stays small, but ClickHouse will quite happily eat as much RAM as you give it for in-memory merges and query caching. The decision is roughly: how many pageviews per month, and how many sites?

VPS 500 G12 — only for tiny single-site instances

Specs: 2 vCore, 4 GB DDR5 ECC, 128 GB NVMe, traffic included. Around €5.91/month (verify on netcup.com).

The official docs say 2 GB RAM is the recommended minimum; 4 GB on this tier gives ClickHouse the headroom it needs without swapping. It works for a single low-traffic site (think a personal blog or a docs site under 50,000 monthly pageviews), but ingest spikes and the daily merge windows are tight enough that any sustained traffic surge will push you toward swap.

Good fit if: you are tracking a single site under 50k monthly pageviews and you want the cheapest possible bill. Honest about: the 4 GB RAM is the absolute floor for this stack — a second tracked site or a traffic spike from a Hacker News post is going to be uncomfortable.

There is no dedicated VPS 500 coupon category — use the €5-off-any-order code:

• 36nc17718015547
• 36nc17718015541
• 36nc17718015544

VPS 1000 G12 — recommended for most Plausible deployments

Specs: 4 vCore, 8 GB DDR5 ECC, 256 GB NVMe, traffic included. Around €10.37/month (verify on netcup.com).

This is the tier the article was written around. 8 GB RAM gives ClickHouse comfortable working memory for its merges, leaves room for PostgreSQL plus the BEAM VM, and has slack for the occasional clickhouse-client query you will run by hand. 256 GB NVMe holds many years of pageview data — Plausible's per-event row is small (hundreds of bytes uncompressed, a fraction of that after ClickHouse's columnar compression). Realistic ceiling: low-millions of monthly pageviews across a handful of sites without thinking.

Good fit if: you are tracking a marketing site, a SaaS dashboard, a documentation site, or a small portfolio of sites for an agency. This is the answer for most readers.

Coupons (each pops a different code at build time):

• 5799nc17800061382
• 5799nc17718015261
• 5799nc17800061381

VPS 2000 G12 — when traffic crosses single-million pageviews

Specs: 8 vCore, 16 GB DDR5 ECC, 512 GB NVMe, traffic included. Around €19.25/month (verify on netcup.com).

At low single-million monthly pageviews and above, ClickHouse starts to want more RAM for its merge windows and larger query caches. 16 GB makes the dashboard responsive even on multi-year breakdowns over a busy site. 512 GB NVMe is enough for a decade of pageview history at that traffic level. The 8 vCores absorb the Bandit web server's request bursts without contention with the ClickHouse merge workers.

Good fit if: you are an agency tracking many client sites, you are running a high-traffic publication, or you simply want to run other services (Vaultwarden, Mealie, a Forgejo) on the same box without resource contention.

Coupons:

• 5800nc17718015230
• 5800nc17804382710
• 5800nc17802654090

RS 1000 G12 — when query latency matters

Specs: 4 dedicated AMD EPYC 9645 cores, 8 GB DDR5 ECC, 256 GB NVMe. Around €12.79/month (verify on netcup.com).

Same RAM and disk as the VPS 1000 G12, but the cores are dedicated rather than oversubscribed. ClickHouse does most of its query work in vectorised loops that benefit from consistent CPU access; on a shared-vCPU tier, a noisy neighbour can occasionally make a "last 30 days" pivot take five seconds instead of one. Dedicated EPYC 9645 cores remove that variance entirely. For a customer-facing analytics product where you embed Plausible widgets in your own UI via the Stats API, the predictability is worth the few extra euros.

Coupons (Root Server codes give two free months):

• 5159nc17718015443
• 5159nc17718015441
• 5997nc17755880771

Comparison

If you are trying Plausible for the first time on a single small site, take VPS 500 G12 and accept the 4 GB ceiling. If you are putting it in front of a real audience and want a clean operational story, take VPS 1000 G12 — it is the right answer for almost everyone reading this. If you are tracking many sites or one popular one, jump to VPS 2000 G12 and stop thinking about it. If query latency is in your product's user experience (you are embedding Plausible-driven charts in customer dashboards), spend the extra two euros on RS 1000 G12 for the dedicated cores.

Web Hosting is not a fit here — Plausible needs persistent Elixir, ClickHouse, and PostgreSQL daemons. Shared hosting cannot run any of them.

Conclusion

A working Plausible Community Edition install on a Netcup VPS 1000 G12 lands at roughly €10.37/month after the first free month from 5799nc17774618550, with 256 GB of NVMe headroom and an 8 GB RAM budget that keeps ClickHouse honest. That is roughly the cost of the cheapest Plausible Cloud plan, except the data lives on hardware in Germany under jurisdiction your privacy lawyer already understands, and the line item does not scale with your pageview count.

If you only need a few euros off the first invoice on any product — a domain, a second VPS, a Web Hosting upgrade — drop the €5-off-any-order coupon 36nc17718015543 in at checkout. It stacks cleanly with VPS-specific codes on a separate order.

Things to keep an eye on once it is running: the ClickHouse data directory size (it grows steadily but predictably; check it monthly until you have a feel for the slope), the v3.x changelog before each docker compose pull (Plausible CE has shipped breaking ClickHouse schema migrations in the past, and the upgrade path is "stop, pull, run migrations, up" rather than "rolling restart"), and the daily Postgres dump (verify it actually restores once a quarter — backups you have not tested are not backups).

The dashboard is yours, the visitor data is yours, and the bill is one fixed line item per month. That is the whole point.