Tells you when something you self-host has a security fix you actually need
🌐 Live demo · 📦 Latest release
Contents
Patchcall reads your Docker host, works out which app each container is and what version it's on, and checks that app's own security advisories on GitHub. When one catches your version and there's a fixed release out, you get one alert saying what to move to. The rest of the time it keeps quiet, so it's the one alert you won't end up muting.
That's different from an image scanner, which buries you in base-image CVEs and only ever sees an app's own advisory if it happens to ship as an npm, pip or Go package (so Jellyfin, Immich or authentik advisories never turn up). And update checkers can't tell a security fix from a new emoji picker.
A few things it does to keep the noise down, and to stay honest:
- It only alerts when a fix exists. Advisories with no fix yet sit at the bottom of the page, greyed out, until there is one.
- If it can't tell what version you're on, or the app isn't one it knows, it says so rather than calling it clear. Green means it checked.
- Ranges written in words ("anything before May") don't get guessed at. If the fix is newer than you, they're listed for you to look at by hand, and the page stays off green until you're past it.
- Exploited-in-the-wild advisories (from CISA's KEV list) get a badge.
It knows the 50-odd most popular self-hosted images out of the box, and reads the org.opencontainers.image.source label for everything else. It talks to GitHub, CISA and the image registries, plus whichever alert channels you set up, and nothing else.
This is the one to go for. Grab docker/compose.yaml and start it:
curl -fsSLO https://raw.githubusercontent.com/NotAFlightRisk/patchcall/main/docker/compose.yaml
docker compose up -dThen open localhost:7282. The first check takes a minute or so.
It puts docker-socket-proxy in front of the Docker socket, so Patchcall can list containers and images and nothing else. Mounting the socket straight in, even read-only, hands over the whole Docker API, which is root on your host.
It works without a GitHub token, but then GitHub allows 60 requests an hour and each check spends roughly one or two per app (more for the few with over 100 advisories), so with more than 40-odd apps a check finishes in two goes, an hour apart. A fine-grained token with public repo access and no permissions at all lifts that to 5,000, and with one, asking about advisories that haven't changed doesn't count at all. Put it in GITHUB_TOKEN.
Quicker, but this hands Patchcall the raw socket:
docker run -d --name patchcall -p 127.0.0.1:7282:7282 \
-v /var/run/docker.sock:/var/run/docker.sock:ro \
--group-add "$(stat -c %g /var/run/docker.sock)" \
-v patchcall:/data \
ghcr.io/notaflightrisk/patchcallThe image runs as an unprivileged user, so the --group-add is what lets it read the socket. It's on GHCR and DockerHub (notaflightrisk/patchcall), for amd64, arm64 and arm/v7. Podman should work through its Docker-compatible socket too, though I haven't tried it.
Every release has a binary for Linux and macOS, plus checksums.txt, a Sigstore signature for it and an SBOM per archive. To check a download is ours:
sha256sum --ignore-missing -c checksums.txt
cosign verify-blob checksums.txt \
--bundle checksums.txt.sigstore.json \
--certificate-identity-regexp '^https://github.com/NotAFlightRisk/patchcall/' \
--certificate-oidc-issuer https://token.actions.githubusercontent.comThen unpack it and run ./patchcall. It reads /var/run/docker.sock by default (set DOCKER_HOST for anything else), and keeps its state in ./data.
You'll need Go 1.26 or newer.
git clone https://github.com/NotAFlightRisk/patchcall.git
cd patchcall
make build
./patchcallmake test and make lint do what you'd expect, and make run does a single check and prints it. Or build the image with docker build -t patchcall .
Everything's an environment variable.
| Variable | Default | What it does |
|---|---|---|
GITHUB_TOKEN |
Lifts GitHub's rate limit from 60 to 5,000 requests an hour | |
DOCKER_HOST |
unix:///var/run/docker.sock |
Where Docker is, unix:// or tcp:// |
PATCHCALL_INTERVAL |
6h |
How often to check, 1m at the quickest |
PATCHCALL_HOST |
127.0.0.1 |
Address to listen on. The image sets 0.0.0.0 |
PATCHCALL_PORT |
7282 |
Port to listen on |
PATCHCALL_ALLOWED_HOSTS |
Extra hostnames it'll answer to, comma separated, or * for any |
|
PATCHCALL_DATA |
./data |
Where it keeps its state. The image sets /data |
PATCHCALL_OVERRIDES |
<data>/overrides.yaml |
Your own app map, see below |
PATCHCALL_INVENTORY |
A list of apps to check instead of reading Docker, see below | |
PATCHCALL_URL |
Your Patchcall's address, so alerts link back to it | |
PATCHCALL_LOG_LEVEL |
info |
debug, info, warn or error |
TZ |
UTC |
Time zone for the times on the page |
Out of the box it only answers to localhost and IP addresses, which stops a dodgy website reaching it through your browser. If you put it behind a reverse proxy or a name like patchcall.home.lan, add that to PATCHCALL_ALLOWED_HOSTS. There's no login, so don't put it on the open internet.
Set up as many as you like. Each one gets a message the first time an advisory with a fix out catches the version you run, and if one channel's down, it's retried on the next check without the others hearing it twice.
| Channel | Variables |
|---|---|
| ntfy | PATCHCALL_NTFY_URL (the whole topic URL, like https://ntfy.sh/my-topic), plus PATCHCALL_NTFY_TOKEN if it needs one |
| Gotify | PATCHCALL_GOTIFY_URL and PATCHCALL_GOTIFY_TOKEN (an app token) |
| Apprise | PATCHCALL_APPRISE_URL, your Apprise API's notify URL, like http://apprise:8000/notify/patchcall |
PATCHCALL_SMTP_URL (smtp://user:pass@host:587, or smtps:// for port 465), PATCHCALL_EMAIL_FROM and PATCHCALL_EMAIL_TO |
|
| Webhook | PATCHCALL_WEBHOOK_URL, which gets a JSON POST with the app, versions and advisories |
There's also an RSS feed of every alert at /feed.xml. To check it's all wired up, docker exec patchcall /patchcall --test-notify sends a test message to each one.
If it maps an image to the wrong repo, can't find one, or picks up advisories for a different part of the project, drop an overrides.yaml in its data folder (with Compose, the commented-out line in the compose file mounts one). It's read fresh on every check, and an entry there replaces the bundled one for the same image.
- images: [ghcr.io/me/my-app]
repo: me/my-app
- images: [lscr.io/linuxserver/bookstack]
repo: BookStackApp/BookStack
name: BookStack
- images: [ghcr.io/home-assistant/home-assistant]
repo: home-assistant/core
skip: [supervisor, companion]
- images: [my/internal-thing]
untracked: Patched by hand, leave it out| Key | What it does |
|---|---|
images |
The images this covers, without a tag |
repo |
The GitHub repo whose security advisories apply |
name |
What to call it on the page |
env |
An env var baked into the image that holds the version, like NEXTCLOUD_VERSION |
ignore_label |
true when the image's version label belongs to something else (Ollama's is Ubuntu's) |
only / skip |
Only keep, or drop, advisories whose package name contains one of these |
unversioned |
A reason it can't be matched, shown instead of guessing |
untracked |
A reason it isn't watched at all, which keeps it out of the way at the bottom |
The version comes from, in order, the env above, the image's version label, a plain VERSION env var, the tag, and finally which version tag on the registry has the same digest as yours (so :latest works for most images). If an app you run should be in the bundled map, an issue or PR adding it to apps.yaml would be really handy.
Point PATCHCALL_INVENTORY at a list and it checks that instead of reading Docker:
- {name: Nextcloud, image: nextcloud, version: 33.0.2}
- {name: Home Assistant, repo: home-assistant/core, version: 2026.10.4}Give it an image to pick up the bundled map's settings, or a repo to go straight to GitHub.
The page at localhost:7282 is the whole thing. Patch-now rows come first, each with the version to move to, then anything it can't check and why, then everything that's clear. /api/status has the same as JSON, if you'd like it on a dashboard.
A few one-off commands, handy for cron or a quick look:
patchcall --once # check now, print it, exit 1 if anything needs patching
patchcall --render out/ # check now and write the page out as static files
patchcall --test-notify # send a test alert everywhere that's set up
Licensed under MIT, © NotAFlightRisk 2026
