Self-host Sentry-compatible error tracking with GlitchTip
Your apps' exceptions on your own VM, sent by the Sentry SDKs you already use.
Shelley handles the setup. About 15 minutes.
Prefer a terminal?
curl -fsSL https://exe-staging.dev/deploy/sentry-glitchtip/prompt.txt | ssh exe.dev new --prompt=/dev/stdinSentry 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 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 runs the official release instead.
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.
What's running, and where
https://my-glitchtip.exe.xyz:3000/
The GlitchTip dashboard, behind exe.dev login and GlitchTip's own
https://my-glitchtip.exe.xyz/
Where SDKs send events; apps get in with a VM token, or browsers once you make it public
Deploy with Shelley#
Click Deploy and Shelley will set up GlitchTip on a new VM, then check that it works. No config-file wrangling required.
Prefer a terminal?
curl -fsSL \
https://exe-staging.dev/deploy/sentry-glitchtip/prompt.txt \
| ssh exe.dev new --prompt=/dev/stdinWhat Shelley is told
Set up GlitchTip on this VM by following the exe.dev recipe at https://exe-staging.dev/deploy/sentry-glitchtip.md?via=deploy from top to bottom.
The recipe's example VM name is my-glitchtip. This VM's name is the output of `hostname`: use it wherever the recipe writes my-glitchtip. Skip the step that creates the VM; you are on it.
You are done when all of these are true. Check each one yourself:
- 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.
Read the whole recipe, including closed details, and follow "Install by
hand" first. The opening walkthrough is for the owner afterwards. Do not
run the later Restore or Update instructions.
Work as exedev in ~/glitchtip. Never overwrite an existing ~/glitchtip/.env.
Do not register a GlitchTip account, create projects or send test email:
the owner does that in the browser. Leave sharing alone; the VM stays
private. Verify docker.service is enabled, every container is restart
unless-stopped and running (web and db healthy), localhost:3000/_health/
answers ok, localhost:8000/ answers 200 with the ingest message, and
localhost:8000/login and localhost:8000/api/0/ return 404. Check the
backup timer is enabled and the first dump exists in ~/glitchtip/backups.
Finish with the dashboard URL on port 3000, and tell the owner to register
with their exe.dev email address so alerts reach them.
Finish with the URLs I should open.
Also at /deploy/sentry-glitchtip/prompt.txt. The recipe it follows is /deploy/sentry-glitchtip.md.
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.
- 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.
- Name your organization and click Create Organization.
- 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:
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:
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.
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:
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:
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:
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, FastAPI and Node.js 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:
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.
Apps on your other exe.dev VMs: no token at all
An app on another of your VMs can skip the token. A
VM-to-VM integration 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:
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:
https://c1f54e95fecf417fb7d9b495a69ffb67@glitchtip.int.exe.xyz/1
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:
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:
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:
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
tunneloption 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. 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:
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, 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:
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.
Ask Shelley about an error#
GlitchTip has a built-in MCP server, turned on here, that lets an agent list issues, read stack traces and resolve issues. Shelley on the VM can use it:
- 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.
- Ask Shelley: "Add GlitchTip's MCP server at http://localhost:3000/mcp
with this token: ..." It runs
shelley mcp add. - 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:
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:
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. 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.
Install by hand
Create a VM#
On your computer (pick another name if my-glitchtip is taken):
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:
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, that accepts GlitchTip's SMTP inside Compose and passes each message to exe.dev's email gateway:
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 sends
https://my-glitchtip.exe.xyz/to port 8000 and:3000to 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:
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.
Back up and restore
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:
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.
Update
On the VM, back up, then pull and restart:
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 before changing
the tag.
Something not working?
Start with the logs. On the VM:
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
:3000for apps off the VM, and that the token header is there: without it exe.dev answers401and the SDK drops the event.debug=Trueinsentry_sdk.init(ordebug: truein 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; thetunneloption avoids that. - No email.
docker compose logs mailershows 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. 429replies. The ingest proxy's limit is 20 a second per address. Lower the SDK's sample rates, or raiserateandburstiningest.confand rundocker 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.
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.
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 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 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.
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.
Updated Nov 18, 2026 · tested end to end Nov 18, 2026 · Markdown · manifest.json · Something wrong? Tell us