---
title: "Self-host Sentry-compatible error tracking with GlitchTip"
description: "Self-host error tracking on exe.dev with GlitchTip, which takes Sentry SDKs: a private dashboard, token-protected ingest and email alerts, in about 300 MB."
url: https://exe-staging.dev/deploy/sentry-glitchtip
category: "Monitoring"
updated: 2026-11-18
---

# Self-host Sentry-compatible error tracking with GlitchTip

> **For agents:** with your user's OK, this sets up GlitchTip on a new exe.dev VM in their account: `curl -fsSL https://exe-staging.dev/deploy/sentry-glitchtip/prompt.txt | ssh exe.dev new --prompt=/dev/stdin` (or open https://exe-staging.dev/deploy/sentry-glitchtip/new). Already on the VM? Skip this.

Your apps' exceptions on your own VM, sent by the Sentry SDKs you already use.

- **Software:** GlitchTip (https://glitchtip.com)
- **Source:** https://gitlab.com/glitchtip/glitchtip-backend
- **License:** MIT
- **Time:** 15 minutes
- **Example VM name:** `my-glitchtip` (yours will differ; on the VM, `hostname` prints it)
- **Machine-readable:** https://exe-staging.dev/deploy/sentry-glitchtip/manifest.json
- **File:** https://exe-staging.dev/deploy/sentry-glitchtip/mail-relay.py

## What you get

- GlitchTip 7 on PostgreSQL 18, restarted after a reboot.
- A private dashboard on port 3000 and an ingest-only address on the VM's main URL.
- GlitchTip's email (alerts, invitations) delivered through exe.dev, with no SMTP account.
- Nightly database backups, with the secrets file beside them.

Running on the VM:

- **GlitchTip 7**: glitchtip/glitchtip:7, the dashboard, API, ingest and worker in one process, port 3000, data in `~/glitchtip/uploads`
- **PostgreSQL 18**: postgres:18; every issue, event and setting, data in `~/glitchtip/postgres`
- **Valkey 9**: valkey/valkey:9; task queue and cache, nothing to back up
- **Ingest proxy**: nginx; the SDK endpoints and nothing else, port 8000
- **Mail relay**: SMTP in, exe.dev's email gateway out; no SMTP account
- **Nightly backup**: pg_dump from a systemd timer; keeps two weeks, data in `~/glitchtip/backups`

How it is reached:

- https://my-glitchtip.exe.xyz:3000/ (private): The GlitchTip dashboard, behind exe.dev login and GlitchTip's own
- https://my-glitchtip.exe.xyz/ (private): Where SDKs send events; apps get in with a VM token, or browsers once you make it public

## Deploy with Shelley

Open https://exe-staging.dev/deploy/sentry-glitchtip/new to create a VM whose agent, Shelley, follows this recipe. From a terminal:

```sh
curl -fsSL https://exe-staging.dev/deploy/sentry-glitchtip/prompt.txt | ssh exe.dev new --prompt=/dev/stdin
```

Or follow the steps below by hand.

Sentry made error tracking normal: an SDK in your app catches every
exception and sends the stack trace, request and release to a dashboard
that groups them into issues. [GlitchTip](https://glitchtip.com) is an
open-source server for those same SDKs. It runs in a few hundred megabytes
with PostgreSQL, where self-hosted Sentry needs 16 GB and more than
fifty containers.

This page runs GlitchTip on an exe.dev VM: a real disk for months of
events, a dashboard that stays behind exe.dev login, and an address that
only accepts events. Your servers reach it with a token, so nothing has to
be public. Alert email goes through exe.dev, with no SMTP account to set
up, and Shelley can read your issues and help fix them. If your team needs
all of Sentry, [Self-host Sentry](/deploy/sentry) runs the official
release instead.

## Sign in and make a project

Open the dashboard Shelley gives you, `https://my-glitchtip.exe.xyz:3000/`.
After exe.dev login you'll see GlitchTip's own sign-in page.

1. Click **Sign Up** and register with **the email you use for exe.dev**.
   exe.dev only delivers the VM's email to you, your team and people you
   share the VM with, so that's the address alerts can reach.
2. Name your organization and click **Create Organization**.
3. Click **New project**, pick a platform (Python, Node.js, React...),
   name it, add a team with the **+** button, and click **Create Project**.

GlitchTip shows the project's **DSN**, the address and key an SDK sends
events to. It looks like this:

```text
https://c1f54e95fecf417fb7d9b495a69ffb67@my-glitchtip.exe.xyz:3000/1
```

The `:3000` is the private dashboard. Apps use the same DSN **without
`:3000`**, which goes to the ingest-only address. A DSN's key only lets
someone send events, which is why Sentry calls it public; it can't read
anything.

## Send your first error

The quickest test runs on the VM itself, where the dashboard port is
reachable without exe.dev login. Open a terminal on the VM (`ssh
my-glitchtip.exe.xyz`) and paste your DSN with its host changed to
`localhost:3000` and `https` to `http`:

```bash
export SENTRY_DSN='http://c1f54e95fecf417fb7d9b495a69ffb67@localhost:3000/1'
cat > /tmp/hello_glitchtip.py <<'EOF'
import os, sentry_sdk

sentry_sdk.init(dsn=os.environ["SENTRY_DSN"], environment="test")

def checkout(cart):
    return sum(item["price"] for item in cart) / len(cart)

checkout([])
EOF
uv run --with sentry-sdk python /tmp/hello_glitchtip.py
```

Python prints a `ZeroDivisionError`, and the SDK sends it before exiting.
Open **Issues** in GlitchTip: the error is there, with its stack trace,
the line that failed and the `test` environment.

<figure>
<img src="https://exe-staging.dev/deploy/sentry-glitchtip/issues.png" alt="GlitchTip's issue list showing a Python ZeroDivisionError, a Node.js error and a browser TypeError, each with its event count" width="1280" height="800" loading="lazy">
<figcaption>Errors from a Python script, a Node.js server and a browser, in one project.</figcaption>
</figure>

## Send errors from your servers

Your apps run somewhere else: another exe.dev VM, a laptop, a cloud
server. The VM is private, so exe.dev's proxy turns away their events
unless they carry a **VM token**, a key that works for this VM's web
addresses and nothing else. The proxy checks it and strips it, so
GlitchTip never sees it.

On your computer, make a token for each app:

```bash
ssh exe.dev ssh-key generate-api-key --vm=my-glitchtip --label=shop-errors --exp=1y
```

Put the token in the app's environment (for example its `.env`, mode
600) as `EXE_VM_TOKEN`, and the DSN **without `:3000`** as `SENTRY_DSN`.
To stop an app sending, remove its key: find it in `ssh exe.dev ssh-key
list`, then run `ssh exe.dev ssh-key remove` with its name or fingerprint. Add `--ips=203.0.113.7/32`
when you make a token to accept it only from your server's address.

**Node.js** (`@sentry/node`) takes extra headers as an option:

```js
import * as Sentry from "@sentry/node";

Sentry.init({
  dsn: process.env.SENTRY_DSN,
  transportOptions: {
    headers: { "X-Exedev-Authorization": `Bearer ${process.env.EXE_VM_TOKEN}` },
  },
});
```

**Python** (`sentry-sdk`) has no such option, so add the header in a
small transport subclass. It overrides an internal method, so pin your
`sentry-sdk` version and recheck after upgrades:

```python
import os
import sentry_sdk
from sentry_sdk.transport import HttpTransport


class ExeDevTransport(HttpTransport):
    def _update_headers(self, headers):
        super()._update_headers(headers)
        headers["X-Exedev-Authorization"] = "Bearer " + os.environ["EXE_VM_TOKEN"]


sentry_sdk.init(dsn=os.environ["SENTRY_DSN"], transport=ExeDevTransport)
```

The rest is the usual Sentry setup: the Django, FastAPI, Flask, Express
and other integrations turn on by themselves when the SDK finds them.
Other SDKs work the same way if they let you add a request header;
if one doesn't, use the public address in the next section. Our
[Django](/deploy/django), [FastAPI](/deploy/fastapi) and
[Node.js](/deploy/nodejs) pages set up apps this fits into.

To check a token from the app's machine, send a request without and with
it. The first is stopped by exe.dev; the second reaches the ingest proxy:

```bash
curl -s -o /dev/null -w '%{http_code}\n' https://my-glitchtip.exe.xyz/                # 401
curl -s -H "X-Exedev-Authorization: Bearer $EXE_VM_TOKEN" https://my-glitchtip.exe.xyz/
# GlitchTip event ingest. The dashboard is private.
```

<details id="apps-on-exe-vms" class="dp-details">
<summary>Apps on your other exe.dev VMs: no token at all</summary>

An app on another of your VMs can skip the token. A
[VM-to-VM integration](/docs/integrations-vm-to-vm) gives it an address
that exe.dev signs on the way out, so the app's VM never holds a key. On
your computer, with `my-app` as the app's VM:

```bash
ssh exe.dev integrations add http-proxy --name glitchtip --target https://my-glitchtip.exe.xyz/ --peer --attach vm:my-app
```

On `my-app`, use the DSN with its host changed to the integration's,
and no custom transport:

```text
https://c1f54e95fecf417fb7d9b495a69ffb67@glitchtip.int.exe.xyz/1
```

</details>

## Catch browser errors

JavaScript errors happen in your visitors' browsers, which can't sign in
to exe.dev or keep a token secret. To accept them, make the VM's main
address public. On your computer:

```bash
ssh exe.dev share set-public my-glitchtip
```

That opens `https://my-glitchtip.exe.xyz/`, port 8000, and only that. The
ingest proxy there passes the SDK endpoints (`/api/<project>/envelope/`,
`store/`, `security/` and `minidump/`, and `/v1/logs` for OpenTelemetry
logs) and answers 404 to everything else. Port 3000 stays behind exe.dev
login. Check from your computer:

```bash
curl -s https://my-glitchtip.exe.xyz/                                    # GlitchTip event ingest...
curl -s -o /dev/null -w '%{http_code}\n' https://my-glitchtip.exe.xyz/login  # 404
```

Then use the DSN without `:3000` in your front end:

```js
import * as Sentry from "@sentry/browser";
Sentry.init({ dsn: "https://c1f54e95fecf417fb7d9b495a69ffb67@my-glitchtip.exe.xyz/1" });
```

What this exposes: anyone who reads the DSN from your page source can
send events to that project, as with any Sentry setup. The proxy limits
each address to 20 events a second (bursts of 200), and you can give
the front end its own key under **Project settings → DSN** and disable it
if it's abused. Servers that already use a token keep working as before.
To close it again: `ssh exe.dev share set-private my-glitchtip`.

> [!TIP]
> The JavaScript SDK's
> [`tunnel` option](https://docs.sentry.io/platforms/javascript/troubleshooting/#dealing-with-ad-blockers)
> sends events to your own backend first, which can forward them with a
> VM token. That keeps this VM private, at the cost of a route in your app.

## Get alerts

GlitchTip emails you when an issue appears, through a small relay that
hands its mail to exe.dev's [email gateway](/docs/send-email). The
gateway delivers to you, your exe.dev team and people the VM is shared
with who have signed in, and drops other addresses (the relay logs why).

To check delivery, on the VM, with your exe.dev email:

```bash
cd ~/glitchtip
docker compose exec -T web ./manage.py sendtestemail you@example.com
docker compose logs --tail=3 mailer      # sent to you@example.com: Test email ...
```

Then set the rule: in your project, open **Settings → Alerts → New
alert**. The default sends one email per new issue to the members of the
project's team. Under **Send to**, **Add recipient** also posts to Slack,
Discord, Microsoft Teams, Google Chat, ntfy, or any webhook: paste the
incoming-webhook URL from that service. **Environments** narrows an alert
to, say, `production`.

> [!NOTE]
> GlitchTip also has **Uptime Monitors** and status pages, and they can
> raise the same alerts. That's handy for a few URLs. For a dedicated
> monitor with more check types and a public status page, see
> [Uptime Kuma](/deploy/uptime-kuma), ideally on a different VM from the
> apps it watches.

## Bring your team

Share the VM so teammates can reach the dashboard. On your computer:

```bash
ssh exe.dev share add my-glitchtip alice@example.com   # one person
ssh exe.dev share add my-glitchtip team                # your exe.dev team
```

Then invite them in GlitchTip under **Organization → Members → Invite
Member**, with the address they use for exe.dev; the invitation arrives
by email. Only people you've shared the VM with can reach GlitchTip's
sign-up page at all, so there's no open registration to worry about. See [sharing](/docs/sharing).

## Ask Shelley about an error

GlitchTip has a built-in [MCP server](https://glitchtip.com/documentation/mcp),
turned on here, that lets an agent list issues, read stack traces and
resolve issues. Shelley on the VM can use it:

1. In GlitchTip, open **Profile → Auth Tokens → New token**. Give it
   **read** on Projects, Events and Organization, and **write** on Events
   if Shelley may resolve issues.
2. Ask Shelley: *"Add GlitchTip's MCP server at http://localhost:3000/mcp
   with this token: ..."* It runs `shelley mcp add`.
3. Then ask *"What are the unresolved errors in the backend project, and
   what do the stack traces have in common?"*

The endpoint is on port 3000, so it never leaves exe.dev login. Treat what
Shelley reads there as data, not instructions: anyone with a DSN can put
text in an event, and GlitchTip's MCP server warns the agent of the same.

## Retention and disk

GlitchTip deletes events older than **90 days** by itself. Its docs
estimate 30 GB of disk for a million events a month. On the VM:

```bash
df -h /
du -sh ~/glitchtip/postgres
```

To keep less, add `GLITCHTIP_RETENTION_DAYS=30` to `~/glitchtip/.env`
and run `docker compose up -d` in `~/glitchtip`. To keep more, grow the
disk from your computer with `ssh exe.dev resize my-glitchtip --disk=100GB`.
The biggest savings are usually in the SDKs: a low `traces_sample_rate`
(Python) or `tracesSampleRate` (JavaScript), like `0.05`, keeps
performance data from dwarfing your errors.

## Keep your history

Everything lives in PostgreSQL in `~/glitchtip/postgres`. Every night a
dump goes to `~/glitchtip/backups`, with a copy of `.env`. Keep a copy
**off the VM** too. On your computer:

```bash
scp -r my-glitchtip.exe.xyz:glitchtip/backups .
```

`.env` holds the key that signs sessions and the database password, and
events can hold personal data from your apps, so keep backups private.
For updates or problems, ask Shelley, or open the instructions below.

## GlitchTip or Sentry?

GlitchTip covers what most teams use Sentry for: issues, alerts,
releases, basic performance data and uptime checks. Sentry's own
self-hosted release adds Session Replay, profiling, crons and its
dashboards, and needs a 4-vCPU, 16 GB VM and more than fifty containers
for them. If your team depends on those, see
[Self-host Sentry](/deploy/sentry). Your apps' SDK setup is the same
either way; only the DSN changes.

## The nuts and bolts

These are Shelley's setup steps and your maintenance reference. Tested
with GlitchTip 7.0.0, PostgreSQL 18.7, Valkey 9, nginx 1.30, sentry-sdk
2.75.0, @sentry/node 11.14.0 and @sentry/browser 11.14.0 on November 18,
2026.

<details id="create-the-vm" data-manual-setup class="dp-details">
<summary>Install by hand</summary>

### Create a VM

On your computer (pick another name if `my-glitchtip` is taken):

```bash
ssh exe.dev new --name=my-glitchtip
ssh my-glitchtip.exe.xyz
```

The remaining commands run **on the VM**, as `exedev`.

### Write the settings

Two random secrets, GlitchTip's address, and the hostnames it answers
to. The file is created only once, so running this again keeps your keys:

```bash
sudo systemctl enable --now docker.service
mkdir -p ~/glitchtip && cd ~/glitchtip
if [ ! -f .env ]; then
  (umask 077; cat > .env <<EOF
POSTGRES_PASSWORD=$(openssl rand -hex 24)
SECRET_KEY=$(openssl rand -hex 32)
GLITCHTIP_DOMAIN=https://$(hostname).exe.xyz:3000
ALLOWED_HOSTS=$(hostname).exe.xyz,localhost
DEFAULT_FROM_EMAIL=glitchtip@$(hostname).exe.xyz
EOF
  )
fi
ls -l .env
```

`ls` shows `-rw-------`. Enabling `docker.service` makes the containers
come back after a reboot. `GLITCHTIP_DOMAIN` is the dashboard's address;
GlitchTip builds DSNs and email links from it.

### Start GlitchTip

The mail relay is a short Python program,
[mail-relay.py](https://exe-staging.dev/deploy/sentry-glitchtip/mail-relay.py), that
accepts GlitchTip's SMTP inside Compose and passes each message to
exe.dev's email gateway:

```bash
cd ~/glitchtip
curl -fsSL -o mail-relay.py https://exe-staging.dev/deploy/sentry-glitchtip/mail-relay.py
mkdir -p uploads && sudo chown 5000:5000 uploads
cat > compose.yaml <<'EOF'
name: glitchtip
services:
  db:
    image: postgres:18
    restart: unless-stopped
    # GlitchTip's partitioned tables need more locks than the default.
    command: -c max_locks_per_transaction=512
    environment:
      POSTGRES_DB: glitchtip
      POSTGRES_USER: glitchtip
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes: ["./postgres:/var/lib/postgresql"]
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U glitchtip -d glitchtip"]
      interval: 5s
      retries: 20
  valkey:
    image: valkey/valkey:9
    restart: unless-stopped
  mailer:
    build:
      dockerfile_inline: |
        FROM python:3.13-alpine
        RUN pip install --no-cache-dir aiosmtpd==1.4.6
    restart: unless-stopped
    init: true
    command: python /mail-relay.py
    volumes: ["./mail-relay.py:/mail-relay.py:ro"]
  web:
    image: glitchtip/glitchtip:7
    restart: unless-stopped
    environment:
      SECRET_KEY: ${SECRET_KEY}
      GLITCHTIP_DOMAIN: ${GLITCHTIP_DOMAIN}
      ALLOWED_HOSTS: ${ALLOWED_HOSTS}
      DEFAULT_FROM_EMAIL: ${DEFAULT_FROM_EMAIL}
      DATABASE_URL: postgres://glitchtip:${POSTGRES_PASSWORD}@db:5432/glitchtip
      VALKEY_URL: redis://valkey:6379/0
      EMAIL_URL: smtp://mailer:2525
      GLITCHTIP_ENABLE_MCP: "true"
      GLITCHTIP_RETENTION_DAYS: ${GLITCHTIP_RETENTION_DAYS:-90}
    ports: ["3000:8000"]
    volumes: ["./uploads:/code/uploads"]
    depends_on:
      db: { condition: service_healthy }
      valkey: { condition: service_started }
      mailer: { condition: service_started }
    healthcheck:
      test: ["CMD", "python", "healthcheck.py"]
      interval: 10s
      retries: 30
  ingest:
    image: nginx:stable-alpine
    restart: unless-stopped
    ports: ["8000:8000"]
    volumes: ["./ingest.conf:/etc/nginx/conf.d/default.conf:ro"]
    depends_on: [web]
EOF

cat > ingest.conf <<'EOF'
limit_req_zone $binary_remote_addr zone=ingest:10m rate=20r/s;

server {
    listen 8000;
    access_log off;
    client_max_body_size 40m;
    resolver 127.0.0.11 valid=30s;
    set $glitchtip http://web:8000;

    # exe.dev's proxy puts the sender's address last in X-Forwarded-For.
    set_real_ip_from 0.0.0.0/0;
    set_real_ip_from ::/0;
    real_ip_header X-Forwarded-For;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $remote_addr;
    proxy_set_header X-Forwarded-Proto https;
    limit_req zone=ingest burst=200 nodelay;
    limit_req_status 429;

    # What SDKs send to; nothing else of GlitchTip is reachable here.
    location ~ ^/api/[0-9]+/(envelope|store|security|minidump)/$ {
        limit_except POST OPTIONS { deny all; }
        proxy_pass $glitchtip;
    }
    location ~ ^/v1/logs/?$ {
        limit_except POST { deny all; }
        proxy_pass $glitchtip;
    }
    location = / {
        default_type text/plain;
        return 200 "GlitchTip event ingest. The dashboard is private.\n";
    }
    location / { return 404; }
}
EOF

docker compose up -d --build --wait --wait-timeout 300
docker compose ps
curl -fsS localhost:3000/_health/; echo
curl -s localhost:8000/
curl -s -o /dev/null -w 'login on the ingest port %{http_code}\n' localhost:8000/login
curl -s -o /dev/null -w 'API on the ingest port %{http_code}\n' localhost:8000/api/0/
printf 'Dashboard: https://%s.exe.xyz:3000/\n' "$(hostname)"
```

All five services are up, `db` and `web` **healthy**. The checks print
`ok`, the ingest message, `login on the ingest port 404` and `API on the
ingest port 404`. On first start GlitchTip creates its tables, which
takes under a minute.

What the pieces do:

- The [HTTPS proxy](/docs/proxy) sends `https://my-glitchtip.exe.xyz/` to
  port 8000 and `:3000` to GlitchTip. Port 3000 always needs exe.dev
  login (or a VM token); port 8000 does too until you make it public.
- GlitchTip 7 runs its web server, task worker and scheduler in one
  process. Valkey holds its queue and cache.
- The ingest proxy forwards only the endpoints SDKs post to. It takes
  the sender's address from the end of `X-Forwarded-For`, which exe.dev's
  proxy sets, and rate-limits by it.

### Set up nightly backups

`pg_dump` copies the database while GlitchTip keeps running. The script
checks each dump is readable and keeps two weeks:

```bash
cd ~/glitchtip
cat > backup.sh <<'EOF'
#!/bin/sh
set -eu
umask 077
cd "$(dirname "$0")"
mkdir -p backups
out="backups/glitchtip-$(date +%Y%m%d-%H%M%S).dump"
docker compose exec -T db pg_dump -U glitchtip -d glitchtip -Fc > "$out.tmp"
docker compose exec -T db pg_restore --list < "$out.tmp" > /dev/null
mv "$out.tmp" "$out"
cp .env backups/glitchtip.env
find backups -name 'glitchtip-*.dump' -mtime +14 -delete
EOF
chmod +x backup.sh

sudo tee /etc/systemd/system/glitchtip-backup.service >/dev/null <<'EOF'
[Unit]
Description=Back up GlitchTip
After=docker.service

[Service]
Type=oneshot
User=exedev
ExecStart=/home/exedev/glitchtip/backup.sh
EOF
sudo tee /etc/systemd/system/glitchtip-backup.timer >/dev/null <<'EOF'
[Unit]
Description=Back up GlitchTip nightly

[Timer]
OnCalendar=daily
Persistent=true

[Install]
WantedBy=timers.target
EOF
sudo systemctl daemon-reload
sudo systemctl enable --now glitchtip-backup.timer
sudo systemctl start glitchtip-backup.service
systemctl list-timers glitchtip-backup.timer
ls -l backups
```

The timer lists its next run, and `backups` holds a `.dump` and
`glitchtip.env`. Uploaded source maps and debug files live in
`~/glitchtip/uploads`; copy that folder too if you use them. Now open
the dashboard and follow the walkthrough at the top.

</details>

<details id="back-up-and-restore" class="dp-details">
<summary>Back up and restore</summary>

For an extra backup, on the VM: `~/glitchtip/backup.sh`.

### Restore

On a new VM, first put the old `glitchtip.env` in place as
`~/glitchtip/.env` (`mkdir -p ~/glitchtip`, then copy it there with
`scp`), and copy a dump into `~/glitchtip/backups/`. If the VM has a new
name, change the three lines with the old name in `.env`. Then run
**Install by hand**, which keeps that `.env`.

On the VM, substitute your dump's filename:

```bash
cd ~/glitchtip
backup=backups/glitchtip-YYYYMMDD-HHMMSS.dump
sudo systemctl stop glitchtip-backup.timer
docker compose stop web ingest
docker compose exec -T db dropdb -U glitchtip --force glitchtip
docker compose exec -T db createdb -U glitchtip glitchtip
docker compose exec -T db pg_restore -U glitchtip -d glitchtip --no-owner --exit-on-error < "$backup"
docker compose up -d --wait
sudo systemctl start glitchtip-backup.timer
```

This empties the database and loads the backup into it. (GlitchTip
splits events into partitioned tables, which `pg_restore --clean`
can't replace in place.) Sign in with the
password you had when the backup was taken; projects keep their DSNs, so
your apps carry on sending to the restored server.

</details>

<details id="update" class="dp-details">
<summary>Update</summary>

On the VM, back up, then pull and restart:

```bash
cd ~/glitchtip
./backup.sh && docker compose pull && docker compose up -d --wait
docker compose exec -T web sh -c 'echo $GLITCHTIP_VERSION'
```

The `7` tag keeps you on GlitchTip 7; database migrations run on start.
GlitchTip ships a major version about once a year, sometimes with
breaking changes (7.0 needed PostgreSQL 15 and renamed settings), so
read the [GlitchTip blog](https://glitchtip.com/blog) before changing
the tag.

</details>

<details id="troubleshooting" class="dp-details">
<summary>Something not working?</summary>

Start with the logs. On the VM:

```bash
cd ~/glitchtip
docker compose ps
docker compose logs --tail=50 web
docker compose logs --tail=20 mailer ingest
```

- **Down after a reboot?** Run `sudo systemctl enable --now docker.service`.
- **The SDK sends but nothing shows up.** Check the DSN has no `:3000`
  for apps off the VM, and that the token header is there: without it
  exe.dev answers `401` and the SDK drops the event. `debug=True` in
  `sentry_sdk.init` (or `debug: true` in JavaScript) prints what the SDK
  sent and the reply.
- **Browser events are blocked.** Make sure the VM is public
  (`ssh exe.dev share show my-glitchtip`) and look for the request to
  `/api/<project>/envelope/` in the browser's Network tab. Ad blockers
  often block Sentry requests; the `tunnel` option avoids that.
- **No email.** `docker compose logs mailer` shows each message and,
  if exe.dev refused it, why. Register with the address you use for
  exe.dev, or share the VM with the person first.
- **`429` replies.** The ingest proxy's limit is 20 a second per
  address. Lower the SDK's sample rates, or raise `rate` and `burst` in
  `ingest.conf` and run `docker compose restart ingest`.
- **Forgot your password?** Reset it from the sign-in page; the email
  comes through the relay. Or on the VM:
  `docker compose exec web ./manage.py changepassword you@example.com`.

</details>

## Frequently asked questions

### Does GlitchTip work with the Sentry SDKs?

Yes. GlitchTip implements Sentry's ingest API, so you install the official `sentry-sdk`, `@sentry/node`, `@sentry/browser` or any other Sentry SDK and give it a GlitchTip DSN. It keeps errors, performance transactions, user feedback and logs. It drops session replays, profiles, cron check-ins and attachments; if you need those, run [full Sentry](/deploy/sentry).

### How much does it cost to self-host Sentry-compatible error tracking?

GlitchTip is free and MIT-licensed, with no event quotas when you host it. You pay for the VM; in our test the whole stack used about 300 MB of memory, so it fits on the smallest [exe.dev plan](https://exe.dev/pricing) beside other VMs. Full Sentry needs 16 GB of memory on its own.

### Can my servers send errors without making anything public?

Yes. Give each app a [VM token](/docs/https-tokens-for-vms) and add it as an `X-Exedev-Authorization` header in the SDK. exe.dev checks it and strips it before the request reaches GlitchTip. See [Send errors from your servers](#send-errors-from-your-servers).

### Why does catching browser errors need a public address?

Your visitors' browsers send the events, and they can't sign in to exe.dev or hold a secret. So the VM's main URL has to be public; it answers only the SDK endpoints, and the dashboard stays private on port 3000.

### How much disk does GlitchTip need?

GlitchTip's docs estimate about 30 GB for a million events a month. Events are kept 90 days by default; set `GLITCHTIP_RETENTION_DAYS` to keep fewer, or grow the disk with `ssh exe.dev resize my-glitchtip --disk=100GB`.

### GlitchTip or full self-hosted Sentry?

GlitchTip if you want error tracking, alerts and basic performance data on a small VM. Full Sentry if your team relies on Session Replay, profiling, crons or Sentry's dashboards, and can give it 4 vCPUs, 16 GB of memory and regular upgrades: see [Self-host Sentry](/deploy/sentry).


## Related

- [Self-host Sentry](https://exe-staging.dev/deploy/sentry.md): All of Sentry on your own VM, behind exe.dev login.
- [Self-host Uptime Kuma](https://exe-staging.dev/deploy/uptime-kuma.md): A little lookout for your websites. Green bars encouraged.
- [Self-host Grafana and Prometheus](https://exe-staging.dev/deploy/grafana.md): Dashboards and alerts for every VM you run, signed in with exe.dev.
- [Self-host Umami analytics](https://exe-staging.dev/deploy/umami.md): Cookie-free web analytics. Your visitors' data stays on your VM.
- [Deploy a Django app](https://exe-staging.dev/deploy/django.md): Your Django app on a computer of its own. git push to deploy.
- [Deploy a FastAPI app](https://exe-staging.dev/deploy/fastapi.md): Your API on a VM of its own. Push to deploy; the data stays put.
