Epure
Open source · Apache 2.0

Error tracking that’s
open source.

Free self-hosted error tracking tool. Keep your Sentry SDK. Swap the DSN.

No card · Unlimited seats · Hardware-bound volume

  • Compose

    2

    Containers. Rust + Postgres 16.

  • Footprint

    <200 MB

    RAM target for the app binary.

  • Price

    $0

    License. Apache 2.0. You pay the VPS.

  • Migrate

    1 DSN

    Keep your Sentry SDK. Change the host.

Why install

Open source error tracking that fits a Hetzner box.

You want production errors grouped and readable. You don’t want Kafka, Redis, and a 20-container compose file for that job.

  • Errors stay on your disk

    Homelab, VPS, or air-gapped. Postgres is yours. No US SaaS inbox for client stack traces.

  • Two containers, not a fleet

    One Rust binary (ingest, API, UI) plus PostgreSQL 16. No Redis. No Kafka.

  • Same SDKs you already ship

    Official Sentry clients. Change the DSN. Land the first issue without a rewrite.

Install tonight

Compose up. Point the DSN. Open the list.

Docker Compose v2. Optional `.env` for the host port. Compose pulls ghcr.io/epure-sh/epure. Default is localhost:8080 with real issues.

  • Clone and compose up

    One command. Optional .env for the host port. Migrations on boot. Health answers ok.

  • Create a project DSN

    Register, name a project, copy the key from setup or Settings → SDK connection.

  • Land the first issue

    Same Sentry SDK. New host. Confirm 202 in the list.

Full core

A free open source error tracking tool.

Apache 2.0. Same product path as Cloud. Exception-only on purpose so a $4 VPS stays enough.

  • Sub-10ms ingest + spike valve

    202 fast. Duplicate storms don’t melt the box or hide the count.

  • Grouping + JS/TS sourcemaps

    Readable stacks. One crash, one issue you can resolve once.

  • Keyboard triage

    j/k through the list. Resolve, ignore, snooze without fighting the mouse.

  • Webhooks + releases

    Ping Slack or your bot. Tie issues to the deploy that shipped them.

  • RLS multi-tenant Postgres

    Org isolation in the database. Monthly partitions. TTL for old events.

  • No EE trap on triage

    Core ingest and issue UI ship in OSS. Cloud is managed hosting, not a locked fork.

Footprint

Open source error tracking vs the stacks you tried.

If Sentry self-host OOMed your VPS, start here.

DimensionSentry self-hostGlitchTipEpure
Compose footprint20+ containers≈4 containers2 containers
Typical RAM floor16–32 GB classModest VPSSmall VPS / laptop
LicenseBSL / cloud-shapedMITApache 2.0
SDK pathNativeSentry wireSentry wire · swap DSN
ScopeErrors + APM + replay + …Errors (+ extras)Exception-only
Self-host priceYour infra + ops timeFree OSSFree · hardware-bound

Competitor footprints from public docs. We don’t claim 100% Sentry protocol parity.

Ops honesty

You own the box. We keep the stack small.

Backups, upgrades, disk during a spike, TLS in front of the app port (default 8080). That work is yours. Two containers means it stays doable for a solo founder on a Friday night.

Prefer managed Postgres and backups? Cloud Pro is $24 flat when it ships. Install free either way.

FAQ

Before you paste the clone.

Is self-hosted really free?
Yes. Apache 2.0, full core: ingest, grouping, issue UI, spike valve, JS/TS sourcemaps, keyboard triage, webhooks. You pay the VPS. No seat lock. Cloud prices live on pricing.
How do I install Epure?
Clone the repo, optional `cp .env.example .env` for ports, then `docker compose up`. Register, copy a DSN. Default dashboard is localhost:8080. Production is `.env.production.example` plus the compose overlay — not the laptop file. Full walkthrough: self-hosting installation.
Will this run on a small VPS?
That is the design. Two containers: Rust plus PostgreSQL 16. Idle stack measured ~82 MiB on 2026-09-12 (Docker Desktop). Size the disk for event growth.
How does this compare to Sentry self-host?
Sentry self-host publishes a 20+ container stack in the 16–32 GB class. Epure is two containers, exception-only, Apache 2.0. Keep official Sentry SDKs and swap the DSN. Details: Epure vs Sentry.
What ops do I still own?
The box, TLS in front of the app port (default 8080; `EPURE_PORT` in `.env`), Postgres backups, disk during a spike, and version upgrades. Two containers keep that list short. Cloud Pro at $24 is managed hosting of the same path: see pricing.
Do I change my Sentry SDK?
No. Keep @sentry/browser, @sentry/node, sentry-python, and the rest. Repoint the DSN. Pick your package on integrations. We do not claim full protocol parity.
Why not GlitchTip?
Same SDK wire path. Epure is exception-only, ships as Rust plus Postgres with no Redis, and prices Cloud at $24 with zero overages. GlitchTip is MIT Django plus workers. Read Epure vs GlitchTip if that stack is already home.
Why not Bugsink or Telebugs?
Both keep Sentry SDKs and skip the 20-container flotilla. Bugsink is one Django container under Polyform Shield with SQLite first. Telebugs is $299 once, Rails plus SQLite, no public Cloud. Epure is Apache 2.0 and Postgres by default. Row by row: Epure vs Bugsink, Epure vs Telebugs.
Will you cripple the OSS build?
The self-hosted binary is the full product. Cloud is managed hosting of that path, not an EE fork of triage. What shipped is on the changelog.

Star the open source error tracking tool.

Then open the docs when you want errors on your own box.

Apache 2.0 · docker compose up · under 200 MB