On this page (7)
This Vaultwarden Docker Compose file runs Vaultwarden 1.37.5 behind Caddy 2.11.7, which provides the HTTPS the web vault needs. We verified the setup by hand on 1.37.3 and 1.37.4 (Oct 2 and 6, 2026) and measured 1.37.5 as the median of three runs on Nov 3. The health check passed through Caddy 3.8 s after docker compose up. Over three runs the two containers idled at 22 MiB (range 21 to 22) and peaked at 67 MiB (range 66 to 69) under a synthetic one-user load on a 2-vCPU lab host (a GitHub Actions runner), so by our sizing rule the stack needs 1 GB of RAM. Vaultwarden 1.37.5 is a security release: if you run an older version, update now (the steps are right below the Test box). Three settings decide whether it is usable and safe: HTTPS in front of the web vault, signups switched off, and an Argon2 hash instead of a plain-text admin token. The file sets the first two. The published .env ships with no usable admin token, so you add your own hash before the first start (steps 3 and 4). We also backed up the running database and restored it into a separate Compose project, leaving the live stack untouched.
Measured readings
Test box: Vaultwarden with Caddy 1.37.5
Measured in our lab on : 3 full runs, each from a fresh stack. Each figure is the median, with the range over the runs under it. The numbers come from the raw result file.
- Idle RAM
- 22 MiBrange 21–22 · 3 runs all containers, median of 3 runs; each run is the mean over 30 s after the stack settled
- Startup peak RAM
- 23 MiBsame when rounded in all 3 runs highest total between healthy and settled
- Peak RAM
- 67 MiBrange 66–69 · 3 runs under load, median of the run peaks
- Settled after
- 127 srange 125–127 · 3 runs after the first healthy response
- Idle CPU
- 0 %same when rounded in all 3 runs of one core, lab host
- Startup
- 3.8 srange 3.7–4.9 · 3 runs to first healthy response
- App version
- 1.37.5
- Tested
- , 3 runs (compose file verified the same day)
- How the figures are made
- Each run starts a fresh stack and goes through setup, settling, the idle window and the load step. We publish the median over the runs and the lowest and highest value, because the lab host and some apps vary from run to run. Runs, median and range
- Lab host
- AMD EPYC 7763 64-Core Processor, 2 cores, 7.7 GiB RAM, x86_64.Ubuntu 26.04.1 LTS, Docker 29.4.2.
- Disk for the images
- About 690 MB with the containerd image store, the default on fresh installs of Docker Engine 29 and later (measured on this lab host, which used the containerd store; never below our estimate of unpacked plus compressed size, plus 10%). Plan for the larger figure. How we size disk
- How idle was measured
- After the stack was healthy and set up, we sampled total RAM until it stayed within max(2% of its mean, 10 MiB) over 60 s (at least 120 s, at most 600 s), then measured idle over the next 30 s. Rule in full
- Peak RAM measured
- Under load. One account, one user, over HTTPS through Caddy. The script first creates 100 encrypted vault items, then for 60 seconds four threads loop over GET /alive, GET /api/config and GET /api/sync (the full vault, about 100 items), and every fifth loop update one item (a database write). It is a synthetic single-user load: no browser, no browser extension, no websocket connections, no attachments. The memory peak is measured over those 60 seconds.
| Container | Idle RAM | Peak RAM (under load) | Image, compressed (download) | Image, unpacked (disk, containerd store) |
|---|---|---|---|---|
| caddy | 13 MiBrange 12–13 · 3 runs | 17 MiBsame when rounded in all 3 runs | 25 MB | 93 MB |
| vaultwarden | 9 MiBsame when rounded in all 3 runs | 50 MiBrange 49–52 · 3 runs | 93 MB | 416 MB |
| Total | 22 MiBrange 21–22 · 3 runs | 67 MiBrange 66–69 · 3 runs | 118 MB | 509 MB |
Every run (3)
| Run | Idle RAM | Peak RAM | Startup peak | Startup | Lab host CPU |
|---|---|---|---|---|---|
| 1 | 21 MiB | 67 MiB | 23 MiB | 4.9 s | AMD EPYC 7763 64-Core Processor |
| 2 (closest to median idle) | 22 MiB | 69 MiB | 23 MiB | 3.8 s | AMD EPYC 7763 64-Core Processor |
| 3 | 22 MiB | 66 MiB | 23 MiB | 3.7 s | AMD EPYC 7763 64-Core Processor |
0 s to 160 s after healthy; the line spans 0 to 23 MiB. Dashed line: settled.
Timeline as a table
| Seconds after healthy | Total RAM |
|---|---|
| 30 | 22 MiB |
| 60 | 22 MiB |
| 90 | 22 MiB |
| 120 | 23 MiB |
| 150 | 22 MiB |
| 160 | 22 MiB |
RAM is MiB (220 bytes); image sizes are MB (106 bytes). The unpacked column is what our lab host's Docker reported; see Disk for the images for other setups. Per-container peaks happen at different moments, so they do not add up to the total peak. Medians of separate columns need not add up either.
Download verified compose fileDownload .envRaw result JSONHow we measure
Lab notes (3)
- Caddy uses `tls internal` (no public domain in the lab); health check and scripts skip certificate verification for that reason.
- ADMIN_TOKEN in the stack is an Argon2 PHC hash made with `vaultwarden hash`; the plaintext lab password is only in test.yaml.
- The idle figure includes Caddy. The vault is idle (one account, one item) until the load step.
Already running Vaultwarden? Update to 1.37.5. The 1.37.5 release notes (Nov 1, 2026) list two security fixes, both rated Medium, in website icons and in emergency access, and say “We strongly advise updating as soon as possible.” The advisories are still private, so we can say nothing about how the flaws work. The previous release, 1.37.4, fixed seven others (one High). Back up first (see Back up and restore). 1.37.5 also refuses to start when a config value is invalid (see What is in 1.37.5 under Update), so check any .env settings you added. Then change the tag on the vaultwarden image line of your compose.yaml to 1.37.5 and run these two commands. If you use the latest tag, the same two commands pull it.
docker compose pull
docker compose up -d --waitWe ran this update from 1.37.3 to 1.37.4 on Oct 6 (see Update below for what we checked and what the releases change for scripts and proxies); 1.37.5 was only started fresh by the lab, and the 1.37.4 to 1.37.5 step was not run. The release notes list the advisories by title and severity; we did not test any of them and say nothing about whether your setup is exposed.
Verified compose file
Two services: vaultwarden (the server, SQLite database in a named volume) and caddy (the HTTPS reverse proxy). Only Caddy publishes ports: 80 and 443, plus 443/udp for HTTP/3. Vaultwarden listens on port 80 on the Compose network only, so from outside that network the vault is reachable only through Caddy’s TLS. The images are pinned to 1.37.5 and 2.11.7, with the digests we tested in comments. The comments in the file are the lab’s.
The Caddyfile is inside this file, under configs, so the one file you copy is the file we ran. Inline content needs Docker Compose 2.23.1 or newer (Docker’s configs reference); we ran Compose 5.3.1 for the manual steps (Compose 5.1.3 in the Nov 3 lab runs).
# Verified compose for Vaultwarden with Caddy, tested 2026-11-03 by the SelfHostBench lab (3 runs; the figures are the median).
# Lab host: AMD EPYC 7763 64-Core Processor, 2 vCPU, 7.7 GiB RAM, x86_64, Docker 29.4.2.
# Floating image tags below were replaced by the version resolved at test time;
# the registry digest is in the comment on each image line.
# Measurements: vaultwarden-caddy.json (schema 3).
# Companion env file: vaultwarden-caddy.env (save it as .env next to this file).
# Secrets are not published: the lab's values are public. In vaultwarden-caddy.env:
# VAULTWARDEN_ADMIN_TOKEN is commented out. Uncomment it and set your own value (the comment above it explains how).
# Vaultwarden (unofficial Bitwarden-compatible server, written in Rust) behind Caddy.
# Caddy terminates HTTPS and is the only service that publishes ports. The web vault needs HTTPS.
# The lab has no public domain, so the Caddyfile (inline, under `configs`) uses `tls internal`:
# Caddy signs the certificate with its own CA. To use a real domain, see the comments in the Caddyfile.
# Needs Docker Compose 2.23.1 or newer (inline `configs` content).
name: vaultwarden-caddy
services:
vaultwarden:
image: vaultwarden/server:1.37.5 # sha256:4fe17f415f90087377d37c755e0ea3cf189dcc6794e49cdd2a9adbb4937d9e1f (version 1.37.5, from label:org.opencontainers.image.version)
restart: unless-stopped
environment:
# The public URL of the vault. Set DOMAIN in the .env file.
DOMAIN: "https://${DOMAIN}"
# false after the first account exists. New users can then only join by admin invite.
SIGNUPS_ALLOWED: "false"
# Argon2 PHC hash of the admin password, generated with `vaultwarden hash`. It lives in the
# .env file, because Compose would otherwise read the $ signs in the hash as variables.
ADMIN_TOKEN: "${VAULTWARDEN_ADMIN_TOKEN}"
volumes:
# Everything lives here: database, attachments, sends, RSA keys, config.json. Back this up.
- vw-data:/data/
# The image already defines a check (/healthcheck.sh, every 60 s). This keeps that script and
# tightens the timing, so Caddy is not held back for up to a minute at start.
healthcheck:
test: ["CMD", "/healthcheck.sh"]
interval: 30s
timeout: 10s
retries: 3
start_period: 30s
start_interval: 2s
caddy:
image: caddy:2.11.7 # sha256:36c24ad91a7ff7bc4c87fe22bfa8df3c4b18da0773d73fc12ee2c52b98c0bb7e (version v2.11.7, from label:org.opencontainers.image.version)
restart: unless-stopped
depends_on:
vaultwarden:
condition: service_healthy
ports:
- "80:80" # Redirects to HTTPS. Also used for the Let's Encrypt HTTP challenge.
- "443:443"
- "443:443/udp" # HTTP/3
environment:
DOMAIN: "${DOMAIN}"
configs:
- source: caddyfile
target: /etc/caddy/Caddyfile
volumes:
# Certificates and Caddy's internal CA. Without these, every re-create issues new ones.
- caddy-data:/data
- caddy-config:/config
networks:
default:
# Lets other containers on this network reach the vault by its public name.
aliases:
- "${DOMAIN}"
configs:
caddyfile:
# Written inside a Compose file, so every Caddy {$VAR} is spelled {$$VAR} here.
content: |
{$$DOMAIN} {
# Self-signed by Caddy's own CA: browsers will warn until you trust it. Lab use only.
# With a real domain that points at this host (ports 80 and 443 open), delete this
# line: Caddy then gets a Let's Encrypt certificate by itself.
tls internal
# The wiki's Caddy example enables this. Remove it if attachment downloads fail in Firefox.
encode zstd gzip
# One proxy line for everything, as in the Vaultwarden wiki's Caddy example.
reverse_proxy vaultwarden:80 {
# Passes the client address to Vaultwarden for its logs.
header_up X-Real-IP {remote_host}
}
}
volumes:
vw-data:
caddy-data:
caddy-config:The .env goes next to it. It holds the domain and a commented-out admin token line.
The published .env ships with no usable admin token, on purpose. The lab ran this stack with its own Argon2 hash, but the password behind that hash is in our public test config. Anyone who kept our hash would have an admin page that anyone can log in to. A placeholder in its place would not be safer. We tried CHANGE_ME_run__vaultwarden_hash__see_article as the value: Vaultwarden 1.37.3 treated it as a plain-text admin password and the admin login with that exact text returned HTTP 200 (lab/notes/vaultwarden-2026-10-02.md, section 11). 1.37.4 did the same (lab/notes/vaultwarden-2026-10-06.md, section 11b), so the placeholder would itself be a known password. We did not re-check this on 1.37.5, and its release notes do not mention the admin token. So the line is commented out instead. With it commented out, Compose prints a warning that VAULTWARDEN_ADMIN_TOKEN is not set, Vaultwarden logs that the admin page is disabled, GET /admin returns the text “The admin panel is disabled, please configure the ‘ADMIN_TOKEN’ variable to enable it”, and POST /admin returns 404 (lab/notes/vaultwarden-2026-10-06.md, section 11a). The stack still starts healthy.
The files you download are therefore not byte for byte the files the lab ran. The compose.yaml has two extra header comment lines. The .env has the lab’s hash removed and a comment explaining how to add yours. Everything the lab measured ran with the lab’s hash in place.
Signups are off in this file and the first account comes from an admin invitation, so without a hash you cannot create the first account. Generate your own hash and put it in the .env before the first start (steps 3 and 4).
# The name you will open the vault at. In the lab it only resolves inside the Compose network.
# For a real deployment set your own domain (its DNS record must point at this host).
DOMAIN=vault.example.com
# ADMIN PAGE: OFF until you set your own hash. The lab's hash is not published: the password behind it is public, so anyone
# who kept it would have an admin page that anyone can log in to. A placeholder would not be safe either, because Vaultwarden
# takes any text that is not an Argon2 hash as a plain-text admin password. Until you set a hash, docker compose prints
# 'The "VAULTWARDEN_ADMIN_TOKEN" variable is not set. Defaulting to a blank string.' on every command: that is expected.
# To turn the admin page on:
# 1. Generate your own hash (it asks for the password twice and needs a terminal):
# docker run --rm -it vaultwarden/server:1.37.5 /vaultwarden hash
# 2. Replace the line below with VAULTWARDEN_ADMIN_TOKEN= followed by the hash, keeping its single quotes. The command prints
# ADMIN_TOKEN='$argon2id$...': copy only the part after the = sign.
# 3. Run docker compose up -d. To turn the page off again, comment the line out again.
# VAULTWARDEN_ADMIN_TOKEN=It differs from the examples in Vaultwarden’s own docs in a few ways. The README’s compose example has no proxy and binds a host port on 127.0.0.1. The wiki’s Caddy example uses a separate Caddyfile, bind mounts, a Let’s Encrypt e-mail address and SIGNUPS_ALLOWED: "true". Ours uses named volumes, keeps the Caddyfile inline, sets signups to false from the first start, takes the admin hash from .env, and tightens the healthcheck timing (see the healthcheck section).
What the Caddyfile does:
{$$DOMAIN}is the site address. Compose reads a$in inline content as the start of a variable (Docker’s reference says inline content is interpolated), so$$is how a literal$is written. Caddy receives{$DOMAIN}, its own placeholder for an environment variable, as in the wiki’s example.tls internalmakes Caddy sign the certificate with its own CA. Caddy’stlsdocs describe it as using “Caddy’s internal, locally-trusted CA”. Browsers and phones do not trust that CA until you install its root certificate, so this line is for a lab or a private test. In our runcurlwithout-kfailed with exit status 60, and the certificate issuer wasCaddy Local Authority - ECC Intermediate(section 2 of the notes).encode zstd gzipis in the wiki’s example. The wiki notes it may cause trouble with some browsers, for example attachment downloads in Firefox, and says to remove it then. Not tested in our lab: any browser.reverse_proxy vaultwarden:80sends everything to Vaultwarden. Theheader_up X-Real-IP {remote_host}line is from the wiki, which says it lets Vaultwarden log the true client address for tools such as fail2ban.
Switch to a real domain
Not run in our lab: it needs a public domain, and the lab has none. This is what Caddy’s automatic HTTPS docs say applies:
- Point a DNS record for your domain at the host, and make ports 80 and 443 reachable from the internet. The docs say the HTTP challenge needs port 80 and the TLS-ALPN challenge needs port 443.
- Set
DOMAIN=vault.yourdomain.comin.env. - Delete the
tls internalline from the Caddyfile incompose.yaml. For a public domain Caddy then obtains a certificate on its own and redirects HTTP to HTTPS. - Run
docker compose up -d. Keep thecaddy-datavolume: Caddy stores its certificates there.
If the host is not reachable from the internet, the wiki has a separate DNS challenge example that needs a custom Caddy build. We did not run it.
Install steps
We ran these steps in a scratch directory on our earlier sandbox lab host on Oct 6, 2026 (Docker 29.6.2, Compose 5.3.1). We did not repeat them on the Actions runner or on 1.37.5. The numbers on this page come from the lab run in vaultwarden-caddy.json (Nov 3, 1.37.5). The raw output of the manual steps is in lab/notes/vaultwarden-2026-10-06.md in the lab repository.
-
Install Docker Engine with the Compose plugin, version 2.23.1 or newer.
-
Make a folder and save the two files above as
compose.yamland.envin it. The download links are on each block.bash mkdir vaultwarden cd vaultwarden -
Generate your admin token hash before the first start. The command asks for the password twice. It needs an interactive terminal: with piped input and no
-tit exited with a panic when we tried it on 1.37.3 on Oct 2 (not re-run on 1.37.4). On 1.37.4 we gave it a pseudo-terminal withscript. The command below names 1.37.4, as we ran it; the published.envnames 1.37.5, which we did not run for this step, so use the tag in your own file.bash docker run --rm -it vaultwarden/server:1.37.4 /vaultwarden hashOur output, for a throwaway password, with the hash cut short:
text Generate an Argon2id PHC string using the 'bitwarden' preset: Password: Confirm Password: ADMIN_TOKEN='$argon2id$v=19$m=65540,t=3,p=4$JCsStWJ3...' Generation of the Argon2id PHC string took: 192.929197msThe command prints
ADMIN_TOKEN='...'. In.env, replace the commented-out line# VAULTWARDEN_ADMIN_TOKEN=withVAULTWARDEN_ADMIN_TOKEN=followed by the hash, keeping its single quotes: copy only the part afterADMIN_TOKEN=. The password you typed is what you will use to log in to the admin page. We made this edit with a script and then started the stack: the admin login page appeared, the right password returned HTTP 200 and a wrong one 401, and the log held no plain-text warning (notes, sections 3b, 3c and 5). -
Set
DOMAINin.envtoo. We leftvault.example.com, a name that exists only inside the Compose network (thecaddyservice has it as a network alias) and in ourcurl --resolveoptions below. -
Start the stack. Your
.envnow has the hash, so Compose prints no “variable is not set” warning. The first start downloads the images: 117.7 MB compressed in total (table below).--waitreturns when the containers are healthy.bash docker compose up -d --waitOn the sandbox host on Oct 6, with the images already pulled, this returned after 3.7 s.
-
Check the containers and the published ports.
bash docker compose ps --format 'table {{.Name}}\t{{.Status}}\t{{.Ports}}'Our output:
text NAME STATUS PORTS vaultwarden-caddy-caddy-1 Up Less than a second 0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp, 0.0.0.0:443->443/udp, 2019/tcp vaultwarden-caddy-vaultwarden-1 Up 3 seconds (healthy) 80/tcpVaultwarden shows only
80/tcp, which is the port the container exposes, not a published one. Port 2019 on Caddy is also not published. -
Check HTTPS and the redirect from plain HTTP. The
--resolveoptions sendvault.example.comto the local host;-kskips certificate verification because oftls internal. On our earlier sandbox lab host (Oct 6, 2026), which reached the internet through an HTTPS proxy, these runs also passed--noproxy. You will not need that unless your own shell sets a proxy.bash curl -sk --resolve vault.example.com:443:127.0.0.1 -o /dev/null -w 'https /alive: %{http_code} http_version=%{http_version} ssl_verify_result=%{ssl_verify_result}\n' https://vault.example.com/alive curl -si -m 5 --resolve vault.example.com:80:127.0.0.1 http://vault.example.com/aliveThe first command printed
https /alive: 200 http_version=2 ssl_verify_result=20, curl’s code for an unknown certificate issuer. The second returned the start of this response:text HTTP/1.1 308 Permanent Redirect Connection: close Location: https://vault.example.com/alive Server: Caddy -
Create your account. The wiki’s admin page article says the admin page can invite users even when registration is disabled. Open
https://<your domain>/admin, log in with the password from step 3, invite your e-mail address, then open the site and create the account with that address. Not run in our lab: these browser steps. The lab made the same calls through the API with a script (vwclient.pyin the lab repository): admin login with the plaintext password,POST /admin/invite, the two registration calls (send-verification-email, thenfinish), log in. All succeeded.
To stop the stack, Docker’s docker compose down removes the containers and keeps the named volumes unless you add -v, which deletes the volumes declared in the file, including the vault. Not run in our lab: the plain command.
docker compose downMeasured resources
Source: vaultwarden-caddy.json, three runs on Nov 3, 2026, each from a fresh stack, with the lab’s own admin hash in .env (the published .env leaves it out, see above) on the lab host (a GitHub Actions ubuntu-latest runner: 2 vCPU AMD EPYC 7763, 7.7 GiB RAM, Docker 29.4.2 with the containerd image store). The Oct 8 runs of 1.37.4 were on the same CPU model with Docker 28.0.4 and overlay2. Every figure below is the median of the three runs, and the range is the lowest to the highest run (why we repeat runs). In each run idle is the mean of 16 samples over 30 s, taken after the stack’s total memory had settled (127 s after the stack was healthy in the median run, 125 to 127 s over the three; rule on the methodology page) and after one account with one vault item existed. Startup peak is the highest total between healthy and settled. Peak is the highest value seen while the load ran. The runs agreed closely: the stack’s idle total was within 1.2 MiB across them, and the load peak within 2.5 MiB. No run was flagged as varying (the flag needs the highest run to be more than 1.5 times the lowest).
The load was a synthetic single-user test over HTTPS through Caddy, from a Python script in a throwaway container. It created 100 encrypted vault items, then for 60 s ran four threads that looped over GET /alive, GET /api/config and GET /api/sync (the whole vault, about 100 items), and updated one item every fifth loop, which writes to the database. That is 14,654 requests in the median run (13,577 to 14,757), with no failures in any run. On our earlier 4-vCPU host the same load made 24,008, so the smaller host served about 60% as many requests in the same 60 s. It used no browser, no browser extension, no websocket connections and no attachments.
| Container | Idle RAM, settled (MiB) | Startup peak (MiB) | Peak RAM under load (MiB) | Image compressed (MB) | Image unpacked (MB) |
|---|---|---|---|---|---|
| vaultwarden | 9.28 (9.18 to 9.33) | 9.69 (9.47 to 9.69) | 50.18 (49.05 to 52.43) | 92.8 | 416 |
| caddy | 12.96 (11.91 to 13.18) | 13.62 (13.54 to 13.94) | 16.95 (16.92 to 17.36) | 24.9 | 93.1 |
| Stack, highest simultaneous total | 22.24 (21.23 to 22.35) | 22.96 (22.86 to 23.24) | 66.81 (66.25 to 68.69) | 117.7 | 509.1 |
Each cell is the median of the three runs with the range in brackets. The stack peak is the highest sum of both containers at one instant, so it is lower than the sum of the per-container peaks, and the medians of separate columns need not add up. The compressed sizes are registry numbers. The unpacked sizes are what Docker reports on the lab host, which this time ran Docker 29.4.2 with the containerd image store (the Oct 8 runs used overlay2 and showed 366.3 MB for the 1.37.4 and Caddy images). That store also keeps the compressed layers, so its figure is higher; the earlier sandbox host (Docker 29.6.2, containerd store) showed 495.1 MB for the 1.37.4 pair. The rise from 366.3 to 509.1 MB is mostly the image store, and we did not separate it from any change in the images (the Vaultwarden download is 92.8 MB against 90.4 MB). For disk we plan for unpacked plus compressed size plus 10%, and when the lab itself ran on the containerd store the figure is not below what it measured: about 690 MB (how we size disk). We did not measure overlay2 this time. CPU, medians of the three runs; this runner has 2 vCPUs, so 200% is the most the stack can use:
| Container | Idle CPU, mean (% of one core, lab host) | Load CPU, mean (% of one core, lab host) | Load CPU, max (% of one core, lab host) |
|---|---|---|---|
| vaultwarden | 0.0 | 56.5 | 63.0 |
| caddy | 0.0 | 39.0 | 43.5 |
| Stack | 0.0 | 95.5 | 106.3 |
The script also timed each request from inside the Compose network. These figures (medians of the three runs) include the Python client and are valid for the lab host only:
| Request | Count (median run) | Median (ms, lab host) | 95th percentile (ms, lab host) |
|---|---|---|---|
GET /alive |
4,580 | 10.9 | 20.1 |
GET /api/config |
4,580 | 10.6 | 19.6 |
GET /api/sync (about 100 items) |
4,580 | 24.1 | 38.9 |
PUT /api/ciphers/<id> (one item) |
914 | 17.1 | 28.5 |
What the numbers say:
- Vaultwarden itself idled at 9.3 MiB with one account, and Caddy at 13.0 MiB. The proxy used more memory than the password server at idle. For comparison, a separate lab run of the 1.37.4 image without Caddy, without an account and without a load step (
vaultwarden.json, Oct 8, not re-run on 1.37.5) idled at 7.07 MiB (7.06 to 7.33 over three runs, no variance flag). - Under load Vaultwarden grew to 50.2 MiB (median peak; 49.1 to 52.4 over the runs). We did not look into what that memory was. The lab sampled only 2 s past the end of the load, then removed the stack, so we do not know whether it falls back.
- By our sizing rule (the highest peak of any run, 68.7 MiB, times 1.5, rounded up to 1, 2, 4, 8, 16 or 32 GB) the stack needs 1 GB. Against the Oct 8 runs of 1.37.4 on the same CPU model (25.3 to 25.9 MiB idle, 68.6 to 72.4 MiB peak, Caddy at 16.3 MiB idle), the 1.37.5 runs are about 3 MiB lower on idle and 4 MiB on peak, and Caddy is 3 MiB lower. The Docker version (29.4.2 against 28.0.4), the kernel, the runner image and the Caddy image behind the 2.11.7 tag (a different digest from Oct 8, same reported version) all changed in the same step as Vaultwarden, so we claim no cause for the change. Earlier measurements of this stack on the sandbox host (4 vCPU) gave higher peaks: three runs on 1.37.3 on Oct 2 measured 22.2 to 23.6 MiB idle and 82.8 to 88.6 MiB peak (
lab/notes/vaultwarden-2026-10-02.md, addendum), and three 1.37.4 runs on Oct 6 measured 23.4 to 25.4 MiB idle and 82.6 to 92.7 MiB peak. The peak fell by about a quarter on the Actions runner while the requests fell by a third. We think the load, which is capped by time and not by request count, pushes less work through a smaller host, but we did not test that. - The Bitwarden-default admin hash (
m=64 MiB, t=3, p=4per the wiki) asks for 64 MiB of memory each time the admin password is checked. Not measured in our lab: our load made no admin logins.
What we did not measure: real Bitwarden clients (browser extension, mobile app, desktop), live-sync websocket connections, several users or organizations, attachments and Sends under load, ARM hosts, and memory growth over days.
Gotchas, upgrade and backup
The manual checks in this section ran on Vaultwarden 1.37.3 or 1.37.4 and Caddy 2.11.4 or 2.11.7 on our earlier sandbox host (Oct 2 to 6, 2026, Docker 29.6.2). We did not repeat them on the Actions runner or on 1.37.5; the dates below say which version each one used.
HTTPS is required for the web vault
The Vaultwarden README says the web vault “requires the use of HTTPS and a secure context” for the Web Crypto API, so it only works over HTTPS. The wiki’s Enabling HTTPS page recommends a reverse proxy, mentions Caddy first for its built-in Let’s Encrypt support, and lists a private CA as “not recommended” because of pitfalls and inconveniences. We did not open the vault in a browser, so we did not see the failure itself. We built the file around the documented requirement: Caddy is the only service with published ports, and plain HTTP gets a 308 redirect to HTTPS (step 7). tls internal is the private-CA route. Use it to test the stack, then switch to a real domain.
The admin token: hash it, and mind the dollar signs
The admin page exists only when ADMIN_TOKEN is set. The wiki’s admin page article says to hash the token as an Argon2 PHC string, because configuration is usually stored in plain text. vaultwarden hash is the built-in generator. Its default uses the Bitwarden parameters (m=64 MiB, t=3, p=4); --preset owasp uses m=19 MiB, t=2, p=1. We checked both presets in the 1.37.4 --help output (lab/notes/vaultwarden-2026-10-06.md, section 3a).
What we ran against 1.37.4, with the hash in the stack and the plaintext password typed at the login:
| Admin login attempt | Result |
|---|---|
| A wrong password | HTTP 401 |
The $argon2id... hash itself used as the password |
HTTP 401 |
| The plaintext password the hash was made from | HTTP 200 and a VW_ADMIN cookie (HttpOnly, SameSite=Strict, Secure, Max-Age=1200) |
So you log in with the plain password, never the hash. The wiki says the admin session lasts 20 minutes by default, which matches Max-Age=1200.
- Plain text prints a warning. A container started with
ADMIN_TOKEN=plain-text-tokenloggedYou are using a plain text `ADMIN_TOKEN` which is insecure.and a pointer tovaultwarden hash. The hashed stack logged no such line. - Dollar signs. A PHC string contains five
$. In a Composeenvironment:block they must be doubled to$$, or Compose reads them as variables and the token is wrong. The wiki’s alternative, which our file uses, is a.envfile with the hash in single quotes and plain$signs.docker compose configprints the value with$$(it re-escapes it), whiledocker exec ... printenv ADMIN_TOKENshowed the single-$hash, which is what Vaultwarden needs to see. - Saving settings in the admin page creates
config.json. The wiki says values in it take precedence over environment variables, so a later change to the same variable in.envis ignored. We saved one setting (invitation_org_name). The resultingconfig.jsonheld only that setting, not the admin token. Not tested in our lab: what other settings write, and the precedence rule itself.
Lock down the admin page
Through Caddy as written, /admin is reachable from anywhere that can reach your domain. With a hash set, GET /admin on our stack returned the login page (HTTP 200), so the password is the only protection. There are two ways to narrow that. The first is documented in the Vaultwarden wiki. The second is Caddy configuration; the wiki’s admin page article does not cover proxy restrictions, so its source is Caddy’s docs. We ran both on a scratch copy of the verified files, not on the file the lab measured (lab/notes/vaultwarden-2026-10-06.md, sections 11a and 12; the loopback detail below is from lab/notes/vaultwarden-2026-10-02.md, section 15).
Turn the page off after setup. The wiki’s “Disabling the admin page” section says to make sure that neither ADMIN_TOKEN nor DISABLE_ADMIN_TOKEN is set and that no "admin_token" key exists in config.json (if that file exists), then recreate the container. In our file that means commenting the VAULTWARDEN_ADMIN_TOKEN line out again in .env and running:
docker compose up -dCompose recreated the Vaultwarden container. Afterwards GET /admin returned HTTP 200 with the text “The admin panel is disabled, please configure the ‘ADMIN_TOKEN’ variable to enable it” (a 200 with no login form), and POST /admin with the old, correct password returned 404. Our data folder had a config.json at that point (from the one saved setting), and it held no admin_token key, so we did not test the case where it does. To use the admin page again, put the hash line back and run the same command. Do not set DISABLE_ADMIN_TOKEN to get around the hash: the wiki says that gives unrestricted access to the admin panel. Not tested in our lab: DISABLE_ADMIN_TOKEN.
Block /admin in the Caddyfile. This stops requests for the page at the proxy, whatever the password. Add these two lines to the Caddyfile inside compose.yaml, above the reverse_proxy line. Tested on a scratch copy with the admin hash set; this is not part of the verified file above:
@admin path /admin /admin/*
respond @admin 403Before the change, GET /admin, /admin/, /%61dmin and //admin all reached Vaultwarden (HTTP 200), /admin/users returned 401, and the admin login with the right password returned 200. Caddy’s path matcher is exact unless you add *, which is why the pattern has both /admin and /admin/*. Caddy’s path matcher docs say matches are case-insensitive and that the request path is normalized (URL-decoded) before matching, which is why the encoded and doubled-slash forms are covered. After the change, /admin, /admin/, /admin/users, /ADMIN, /%61dmin, //admin and the admin login all returned 403 from Caddy, while /alive and /api/config still returned 200. We first ran this on Caddy 2.11.4 and repeated it on 2.11.7, the version in the file now, with the same results; Caddy’s releases page lists a path-canonicalization fix in 2.11.6. Two cautions from the same test:
- A plain
docker compose up -dafter editing the inline Caddyfile left the Caddy container running, and/adminstill returned 200. Runningdocker compose up -d --force-recreate --no-deps caddyapplied the change. - The block is at the proxy only. A request made inside the Vaultwarden container straight to its port 80, skipping Caddy, still reached the admin login (200). Vaultwarden publishes no port in this file, so that needs access to the Docker host or a container on the network.
To use the admin page while the block is in place, remove the two lines, recreate Caddy, and add them back afterwards.
To allow some addresses instead of none, Caddy’s remote_ip matcher matches the address of the immediate peer. This version blocks /admin for every client outside the private ranges:
@admin_outside {
path /admin /admin/*
not remote_ip private_ranges
}
respond @admin_outside 403With it, a request from the lab host’s own loopback address got 200 for /admin (on Caddy 2.11.7 as well): Caddy saw the client as 172.18.0.1, the Docker bridge gateway, which is inside private_ranges (section 15 of the Oct 2 notes). Swapping private_ranges for 192.0.2.0/24, a range that does not contain that address, returned 403. That shows both outcomes of the matcher. The first outcome is also the catch. If Docker or a proxy or tunnel on the same host hands Caddy a private address instead of the visitor’s, every visitor counts as private and this rule lets them all in to the login page. The /admin block above has no such dependency, so prefer it unless you have checked from an outside address what Caddy sees. We did not test the remote_ip rule from another machine or through another proxy. The Caddy docs say that to match the client address from HTTP headers you need the client_ip matcher instead, so remote_ip would see only your CDN or upstream proxy if you have one. Not tested in our lab: client_ip.
Signups: off from the first start
The wiki’s own compose example sets SIGNUPS_ALLOWED: "true" with a comment to switch it to false after you create your account. Our file starts at false, so there is no window in which a stranger can register. The first account is created by invitation instead (step 8), which is why the admin hash comes first: with the admin page off, nobody can send an invitation. With the setting off, an uninvited registration through the API returned HTTP 400 Registration not allowed or user already exists, and the invited address registered normally. On 1.37.4 that check goes through POST /identity/accounts/register/send-verification-email, the first of the two registration calls, because the old register endpoint is gone.
One trap: GET /api/config still reported "disableUserRegistration": false on our stack. The 1.37.4 source (config.rs) computes that field as true only when signups are off, the domain whitelist is empty, and either mail is enabled or invitations are disallowed (there is also an SSO-only case, which we did not use). We had no mail set up and invitations were allowed, so the field read false while uninvited registration was refused. Do not use that field to check your setting. Try an uninvited registration instead.
The healthcheck
The Vaultwarden image already defines a healthcheck. The 1.37.4 Dockerfile has HEALTHCHECK --interval=60s --timeout=10s CMD ["/healthcheck.sh"], and docker image inspect on our pulled image showed the same: interval 60 s, timeout 10 s. The script calls curl --insecure --fail on /alive at localhost, on the container’s own port 80. It checks the app inside its container and never goes through Caddy. Caddy’s image defines no healthcheck (docker image inspect on 2.11.7 printed null).
Our file keeps that script and changes only the timing:
healthcheck:
test: ["CMD", "/healthcheck.sh"]
interval: 30s
timeout: 10s
retries: 3
start_period: 30s
start_interval: 2sstart_interval makes Docker check every 2 s during the 30 s start_period. Docker’s Compose reference lists it and notes it was introduced in Compose 2.20.2. It matters because Caddy waits for service_healthy. We ran the same file with the healthcheck: block removed, so the image’s default applied:
| Healthcheck | Time for docker compose up -d --wait |
|---|---|
| Image default (every 60 s) | 61.7 s |
| Our override (every 2 s while starting) | 3.7 s |
To check the proxy path as well, use the curl command from step 7. The lab’s own health check did that: https://vault.example.com/alive through Caddy with curl -k, because the certificate comes from Caddy’s internal CA. It passed 3.4 s after the start (median of 3 runs, 3.4 s in all three).
Update
The file pins exact tags, so an update is an edit. Back up first (next section), then change the tag on the vaultwarden image line and delete the stale digest comment after it. We ran the update on a stack at 1.37.3 holding one account and 11 vault items: we changed 1.37.3 to 1.37.4 with sed, then ran:
docker compose pull
docker compose up -d --waitAfterwards /vaultwarden --version printed Vaultwarden 1.37.4, the account logged in, all 11 items decrypted, and an access token issued before the update was still accepted. The Vaultwarden log held no error, warning or migration line. We tested one patch update, not a major one.
The wiki’s latest example updates with docker compose pull && docker compose up -d. We pin a tag instead, because a floating tag changes the next time you pull.
What is in 1.37.5. The 1.37.5 release notes (Nov 1, 2026; the page shows “01 Nov” without a year; read through a web-fetch tool on Nov 4, so a summary) say:
- Security. Two fixes, both Medium: website icons (GHSA-x9cq-f669-vrr4, CVSS 5.3) and emergency access (GHSA-9pjj-f9g5-3x4c, CVSS 4.3), and “We strongly advise updating as soon as possible.” The notes say the advisories stay private until CVE assignment, and both pages returned “not found” to us on Nov 4. We know the titles and scores only, and we did not test either.
- Startup now fails on invalid config. Invalid values stop the server with an error. The limits the notes give:
LOGIN_RATELIMIT_MAX_BURST,TRASH_AUTO_DELETE_DAYS,EVENTS_DAYS_RETAINandSMTP_TIMEOUTmay not exceed 65535,EMAIL_ATTEMPTS_LIMITmay not exceed 255, negative values are rejected, the rate-limit*_SECONDSand*_MAX_BURSToptions,DATABASE_TIMEOUTandDATABASE_IDLE_TIMEOUTmust be at least 1,DATABASE_MIN_CONNSmay not exceedDATABASE_MAX_CONNS, andDUO_CONTEXT_PURGE_SCHEDULEandPURGE_INCOMPLETE_SSO_AUTHmust be empty or a valid cron expression. Our file and.envset none of these, so the stack started normally in all three runs. If you have added one, check it first, because a container that exits at start looks like a broken update. - Web vault. The bundled web vault is v2026.10.1. A web vault you serve yourself that is older than v2026.7.1 may be incompatible. The notes add that the update is required for web vault 2026.7.1 and later to switch two-step login methods on or off, and for 2026.9.0 and later to take over an account through emergency access. We ran only the bundled one.
- Smaller items. The server closes WebSocket connections that stop responding, Rocket is updated to 0.5.2, and the rest is bug and compatibility fixes. The page lists no memory change, no database migration and no Compose or Docker change. Our numbers are in the table above; the RAM changes there cannot be credited to the release (see the note under the sizing bullet).
What is in 1.37.4. The 1.37.4 release notes (Oct 5, 2026, read through a web-fetch tool on Oct 6) say the release “contains security fixes” for seven advisories (one rated High at 8.1, five Medium, one Low) and “We strongly advise updating as soon as possible.” The ones we noticed in the upgrade notes:
- Reverse proxies. With
IP_HEADER=X-Forwarded-For, the client IP is now the rightmost address that is not inIP_HEADER_TRUSTED_PROXIES. Our file sets neither variable. Not tested in our lab: that setup. - Removed endpoints. The old
POST /identity/accounts/registerandPOST /api/accounts/preloginare gone. Our lab script used the first one and got HTTP 404 on 1.37.4, so we moved it to the two-call registration (send-verification-email, thenfinish). The file itself is not affected. The change matters if you have your own scripts or tools that call the API directly. We did not test real clients, so we cannot say whether any old client still uses the removed endpoints. - Vault items. Our script’s first write of a vault item on 1.37.4 returned HTTP 422 and the server log said the
encryptedForfield was missing. The release notes do not list this as an upgrade note. The script now sends the user’s id there. In the 1.37.4 source (ciphers.rs) the field is marked “Added in web-v2025.6.0”, so current web vault clients should already send it; this is a reading of a code comment, not a test. It matters only to your own API scripts. We did not test real Bitwarden clients. - Smaller items. Old
bw send receiveCLIs (2026.4.2 and older) stop working,DUO_USE_IFRAMEis removed, a few feature flags are removed, and there is a newemail/recover_twofactortemplate. Not tested in our lab. - Not in the notes. The page lists no memory, performance, SQLite, migration, admin-page or
ADMIN_TOKENchange. Our numbers at the time agreed: 25 MiB idle and 70 MiB peak on the Actions runner (medians of three runs, Oct 8); the 1.37.3 and 1.37.4 runs on the earlier host were at 22 to 25 MiB idle and 83 to 93 MiB peak. The image still reportsWeb-Vault 2026.7.0.
The file’s caddy:2 tag moved too: the lab resolved it to 2.11.4 on Oct 2 and to 2.11.7 on Oct 6. Caddy’s releases page lists security fixes and a 16 KiB request-header limit in 2.11.6, and fixes for crashes introduced in 2.11.6 in 2.11.7. We re-ran everything on this page that goes through Caddy. Not tested in our lab: how the new limits affect real clients.
Back up and restore
The wiki’s backup page sorts the data folder into three groups. Required: db.sqlite3 and the attachments folder. Recommended: config.json and the rsa_key* files. Optional: sends and icon_cache. It says to use the SQLite CLI’s .backup command (the online backup API) for a database that may be in use, or the built-in /vaultwarden backup command from version 1.32.1, and that plain file copies are an option only when the database is not in use. It also says the Docker image has no sqlite3 binary. In our data folder, after one account, one attachment, one file Send and one saved admin setting, the files were db.sqlite3 (with -shm and -wal while running), attachments/, sends/, config.json, rsa_key.pem and a tmp folder. There was no rsa_key.der or rsa_key.pub.der, which the wiki’s example tree lists, so check your own folder.
We backed up a running stack that held one account, 21 vault items, one 200,065-byte attachment and one 50,065-byte file Send. The container name comes from the project name in the file:
mkdir -p backup
docker exec vaultwarden-caddy-vaultwarden-1 /vaultwarden backupIt printed Backup to 'data/db_20261006_081755.sqlite3' was successful; the file is written inside the data volume. The wiki’s sqlite3 .backup command also worked. We ran it from a throwaway Alpine container (SQLite 3.53.4) that mounted the live volume. These two lines were saved as sqlite-backup.sh (the script we ran also printed the SQLite version and listed the backup folder):
apk add -q sqlite
sqlite3 /data/db.sqlite3 ".backup '/backup/db-cli.sqlite3'"docker run --rm -v vaultwarden-caddy_vw-data:/data -v "$PWD/backup:/backup" -v "$PWD/sqlite-backup.sh:/s.sh:ro" alpine:3 sh /s.shBoth files were 299,008 bytes, passed PRAGMA integrity_check, and held 1 user, 21 items, 1 attachment and 1 Send. We used the built-in file for the restore. The remaining files came out of the volume with three lines saved as files-backup.sh (ours also ended with an ls of the backup folder) and run in a throwaway container. In the lab we pulled the image as mirror.gcr.io/library/alpine:3, because Docker Hub was rate-limiting the host, and our paths were absolute:
cd /data
cp db_*.sqlite3 /backup/
tar czf /backup/vw-files.tar.gz attachments sends config.json rsa_key*docker run --rm -v vaultwarden-caddy_vw-data:/data:ro -v "$PWD/backup:/backup" -v "$PWD/files-backup.sh:/s.sh:ro" alpine:3 sh /s.shThe wiki says attachments, sends and config.json exist only after you have created an attachment, a Send or saved an admin setting. All three existed in our run. If one is missing from your data folder, tar prints a “No such file or directory” error for it, still writes the archive with the rest, and exits with status 1 (checked on Alpine 3 with a folder holding only rsa_key.pem, lab/notes/vaultwarden-2026-10-02.md, addendum). Remove the missing names from the tar line to silence it.
We ran the restore drill into a separate Compose project, so the live stack and its data are never touched. The -p option overrides the name: line in the file, and the volumes take the new prefix (vw-restore-test_vw-data, not vaultwarden-caddy_vw-data). Only the vaultwarden service is created, because Caddy’s ports 80 and 443 belong to the live stack. Save these lines as restore.sh, with BKN set to the name of the database backup file (we passed it with -e; the db_20261006_081755.sqlite3 in the command below is our file, so use the name from your backup folder):
tar xzf /backup/vw-files.tar.gz -C /data
cp "/backup/$BKN" /data/db.sqlite3docker compose -p vw-restore-test create vaultwarden
docker run --rm -e BKN=db_20261006_081755.sqlite3 -v vw-restore-test_vw-data:/data -v "$PWD/backup:/backup:ro" -v "$PWD/restore.sh:/s.sh:ro" alpine:3 sh /s.sh
docker compose -p vw-restore-test up -d --wait vaultwardendocker compose create makes the volume and the container without starting Vaultwarden, so nothing writes to the database before the files are in place. The copy publishes no port; we checked it from a throwaway container on its own project network (vw-restore-test_default). When you are done, remove only the copy:
docker compose -p vw-restore-test down -vThe -v here deletes the volumes of the vw-restore-test project only. After it, docker volume ls still listed the three live volumes. Without -p, docker compose down -v would target the live project, so keep the -p on every command of the drill. Before you rely on a backup, check that the backup folder holds a non-empty db_*.sqlite3 and vw-files.tar.gz, and copy the folder to another machine.
The wiki says to stop Vaultwarden before restoring and, when restoring over existing data, to delete any db.sqlite3-wal file first. Our target was an empty volume, so there was no -wal file. Not run in our lab: a restore over existing data, which is what replacing a lost live stack involves.
The drill ran against a live stack holding one account, 21 vault items, one attachment, one file Send and one saved admin setting. What the restored copy did, checked from a script on its project network:
- The account logged in with its original password, and all 21 items decrypted on the client side.
- The attachment downloaded with the same SHA-256 as the one uploaded before the backup.
- The one Send was listed, the admin page accepted the admin password, and
config.jsoncame back with the saved setting. - An access token issued by the live server before the backup was accepted by the copy (HTTP 200). That token is signed with the
rsa_keyfile, so this shows the key was restored.
What the live stack did meanwhile: the same two containers, with the same IDs and start times before and after; the same rsa_key.pem checksum; the same three volumes; still 21 items. The only differences in the before and after listings were the extra vw-restore-test container and its vw-restore-test_vw-data volume while the drill ran.
As a control we repeated the drill with --exclude='rsa_key*' on the tar line. The login worked and the 21 items decrypted, but the old access token was rejected (HTTP 401) and a new rsa_key.pem had been created. That matches the wiki’s description: without these files users are logged out and must sign in again.
Two cautions from the wiki. config.json and rsa_key.pem hold sensitive data, so encrypt backups that leave the machine. The wiki also says to avoid relying on VM or filesystem snapshots as a backup method. Your .env holds the admin hash, so if you copy it into the backup folder, treat that copy as a secret too. We did not back up icon_cache. With a real domain, Caddy’s certificates live in the caddy-data volume, so back that up too or Caddy will have to obtain new ones. Not tested in our lab.
The same rule as in our Immich restore test applies: a backup you have not restored into an empty volume is a guess. To keep these files off the machine on a schedule, a deduplicating backup tool can take over the copy step. Our restic vs Borg vs Kopia comparison measures three of them on a generated dataset with local repositories; we did not run any of them against this stack. For the online SQLite backup, the built-in command and a cold copy timed and restored side by side, what a plain cp db.sqlite3 loses on a running server, and what a restore without rsa_key*, attachments or config.json costs, see how to back up self-hosted Bitwarden (Vaultwarden).
Vaultwarden vs Bitwarden
Researched, not tested: we ran only Vaultwarden, never a Bitwarden server. Bitwarden’s help pages, read Oct 2, 2026, give 2 GB RAM minimum and 4 GB recommended for the standard Linux deployment and at least 200 MB for the Lite deployment, both as host requirements and both needing an installation ID and key from bitwarden.com/host. Those are not comparable with our measurement of two containers (25 MiB idle, median of three runs). Vaultwarden’s README states that the project “is not associated with Bitwarden or Bitwarden, Inc.”; we did not compare features or licensing.
What we did not measure
- Real clients: the web vault in a browser, the browser extension and the mobile apps. The lab script speaks the same API, but it is not a client.
- Live sync (websocket) connections, several users, organizations, and load with attachments or Sends.
- The Let’s Encrypt path, HTTP/3, SMTP, two-factor login, and databases other than SQLite.
- The browser steps for the admin page, the Caddy lock-down from a machine other than the lab host,
client_ip,DISABLE_ADMIN_TOKEN, and replacing live data with a restore. - The memory cost of an admin login with the Bitwarden-default hash.
- ARM hosts, and memory growth over days.
Where to run it
- Hardware. Vaultwarden with Caddy idled at 22 MiB and peaked at 67 MiB under load (medians of 3 runs) in our lab. The highest reading in any run was 69 MiB. Plan for at least 1 GB of RAM, sized from the highest run. See how much RAM self-hosted apps use.
- VPS. The smallest plan that runs this comfortably has 1 GB of RAM, plus disk for your data and the images. Plan for about 690 MB for the images (Docker's containerd image store, the default on fresh installs of Docker 29 and later).
- Keep it safe. Back up the data volume before you rely on it, and put the app behind a reverse proxy with HTTPS before you expose it to the internet. See backing up self-hosted apps.
How we size: recommended RAM is the highest reading in any of our runs (under load or during startup, not the median) times 1.5, rounded up to the next of 1, 2, 4, 8, 16 or 32 GB. The extra half covers the operating system, Docker, file cache and spikes our sampling can miss. Your own data and extra apps need more. Disk for images: Docker Engine 29 and later uses the containerd image store on fresh installs, which keeps each image twice (as downloaded and unpacked); older installs use overlay2, which keeps it unpacked only. We plan for the larger figure: unpacked plus compressed size, plus 10%, rounded up. Your data volumes and growth come on top.
Related
- Another small always-on container for the same host: AdGuard Home vs Pi-hole v6, a DNS ad blocker pair measured the same way (idle 9.3 MiB for Pi-hole, 26.4 MiB for AdGuard Home, both measured in one job). The published Pi-hole file and the Caddy in this guide both publish host ports 80 and 443, and AdGuard Home’s file publishes 80, so change the left-hand port numbers if they share a host. We did not run them together. The Pi-hole file has its own guide: Pi-hole Docker Compose.
- A self-hosted uptime monitor, which you would run on a separate small box: Uptime Kuma Docker Compose, a single container that idled at 123 MiB in our run (an account and no monitors; 139 MiB peak with 30 monitors). We did not point it at Vaultwarden.
- A single login page in front of several apps behind one proxy: Authentik vs Authelia measured two such servers in one job on one host (idle medians 56 MiB for Authelia and 1,067 MiB for authentik, whose three runs spanned 840 to 1,071 MiB). The full authentik setup is in the authentik Docker Compose guide. We did not put either in front of Vaultwarden.
- How the lab measures RAM, CPU and image sizes: methodology.
- Other apps in the same format: the self-hosted apps index. Running a heavier app on the same box: the Immich Docker Compose guide and its RAM numbers. A file-sync stack with Postgres and Redis, with its own Caddy-in-front test and restore drill: Nextcloud Docker Compose. A media server whose CPU, not RAM, sets the limit: Jellyfin Docker Compose. A smart-home hub that runs on the host’s network instead of behind a proxy port: Home Assistant Docker Compose, which also covers putting a proxy in front of it.
- Official sources used on this page, read Oct 2, 2026 and re-checked on Oct 6, 2026 (the 1.37.5 release notes on Nov 4, 2026): the Vaultwarden README, the 1.37.4 release notes, the 1.37.5 release notes, the wiki pages on Docker Compose, HTTPS, the admin page and backups, Caddy’s automatic HTTPS and request matcher docs, and Bitwarden’s standard and Lite deployment pages.
Update log
- Updated the authentik and Authelia idle figures quoted in Related (1,067 and 56 MiB) after both were re-measured in one job on one host on Nov 8. No measurement on this page changed.
- Updated the Pi-hole (9.3 MiB idle, was 9.4) and AdGuard Home (26.4 MiB idle, was 39.3) figures quoted in Related after the two were re-run together in one job, in both run orders (Nov 5 and Nov 6). No Vaultwarden measurements changed.
- Re-tested on Vaultwarden 1.37.5 (was 1.37.4) with Caddy 2.11.7, median of 3 runs on Nov 3, on an AMD EPYC 7763 (the Oct 8 runs were on the same CPU model) with Docker 29.4.2 and the containerd image store (Oct 8: Docker 28.0.4, overlay2). Idle 22 MiB (range 21 to 22; was 25), peak 67 MiB (range 66 to 69; was 70), startup 3.8 s (was 3.4). Vaultwarden itself idled at 9.3 MiB (was 9.1) and Caddy at 13.0 MiB (was 16.3); the Caddy image digest behind the same 2.11.7 tag differs from Oct 8, and the Docker version, kernel and runner image changed too, so we claim no cause for the RAM changes. The load made 14,654 requests in the median run (was 15,745), no failures. The sizing figure uses the highest run (68.7 MiB; was 72.4) and is still 1 GB. Image download 117.7 MB (was 115.3, the Vaultwarden image is 92.8 MB, was 90.4); unpacked 509.1 MB, the containerd store's figure (was 366.3 MB on overlay2), so the disk figure is now the measured 690 MB (was 530 MB estimated). New in the text: 1.37.5 (Nov 1) has two Medium security fixes (website icons, GHSA-x9cq-f669-vrr4, CVSS 5.3; emergency access, GHSA-9pjj-f9g5-3x4c, CVSS 4.3) that the project's notes say to install as soon as possible, and invalid config values now stop startup; a section on what changed was added to Update. Release page read Nov 4, 2026; the two advisories are private so we know their titles and scores only. The manual steps (hash, lock-down, backup, restore, update from 1.37.3) are from Oct 2 to 6 and were not repeated; the update from 1.37.4 to 1.37.5 was not run.
- Linked the new authentik Docker Compose guide from Related. No measurements changed.
- Linked the new Pi-hole Docker Compose page from Related, next to the note on the shared ports 80 and 443. No measurement changed.
- Updated the authentik idle figure quoted in Related (836 MiB, was 942) after its re-test on 2026.8.5. No measurement on this page changed.
- Linked the new Uptime Kuma Docker Compose page from Related. No measurements changed.
- Linked the new Vaultwarden backup page from the backup section. It restores three backup methods into a fresh stack, 15 checks each, and shows what a plain copy of db.sqlite3 loses on a running server. No measurements on this page changed.
- Linked the new Authentik vs Authelia page from Related (the RAM of two login portals for a reverse proxy, measured on one lab host). No measurements changed.
- Linked the new restic vs Borg vs Kopia page from the backup section (a measured comparison of three backup tools on one generated dataset). No measurements changed.
- Linked the new AdGuard Home vs Pi-hole v6 page from Related. No measurements changed.
- Disk sizing now covers both Docker image stores: plan for about 530 MB for the two images (unpacked plus compressed size plus 10%, for Docker 29 and later with the containerd store), 366 MB on overlay2; was 366 MB only. Dated the sandbox proxy remark. No new measurements.
- Re-tested on our new standard lab host (GitHub Actions runner, 2 vCPU / 8 GB), median of 3 runs, same Vaultwarden 1.37.4 and Caddy 2.11.7. Idle 25 MiB (range 25 to 26; was 24), peak 70 MiB (range 69 to 72; was 91), startup 3.4 s (was 3.8). The load made fewer requests on the smaller host (15,745 in the median run against 24,008), which is the likely reason the peak is lower; we did not test that. Vaultwarden on its own (no Caddy, no account) idled at 7.1 MiB in all three runs (7.06 to 7.33) with no variance flag. The sizing figure uses the highest run (72 MiB) and is still 1 GB. The manual steps (hash, lock-down, backup, restore, update) are from the earlier sandbox host and were not repeated.
- Linked the new Home Assistant Docker Compose page from Related. No measurements changed.
- Results re-measured as the median of 3 runs (methodology change 2026-10-06): idle 24 MiB (range 23 to 25), peak 91 MiB (range 83 to 93), startup 3.8 s; the sizing figure uses the highest run and is unchanged at 1 GB. The entry below quotes the single run it was based on.
- Re-tested on Vaultwarden 1.37.4 (was 1.37.3), a security release of Oct 5 with seven advisories; idle RAM 22 MiB (was 24), peak 84 MiB (was 83), no material change. The file's floating Caddy tag now resolves to 2.11.7 (was 2.11.4): the admin lock-down, HTTPS and healthcheck results repeated unchanged. 1.37.4 removed the old registration endpoint and needs `encryptedFor` in vault items, so our lab script was updated; the admin token, backup, restore and update tests were re-run with the same results.
- Linked the new Jellyfin Docker Compose page from Related (another single-container stack, measured for transcode load). No measurements changed.
- Linked the new Nextcloud Docker Compose page from Related (another Compose stack with a Caddy proxy test and a restore drill). No measurements changed.
- First published. Vaultwarden 1.37.3 behind Caddy 2.11.4 verified in the lab; hashed admin token, healthcheck, update, admin-page lock-down, and a live backup restored into a separate Compose project were run the same day. The published .env carries no admin token.