---
title: "Self-host Vaultwarden"
description: "Run Vaultwarden, the Bitwarden-compatible password manager, on an exe.dev VM: Bitwarden apps, a private admin panel, team sharing, and nightly backups."
url: https://exe-staging.dev/deploy/vaultwarden
category: "Security"
updated: 2026-11-18
---

# Self-host Vaultwarden

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

A Bitwarden-compatible password manager for you and your team.

- **Software:** Vaultwarden (https://github.com/dani-garcia/vaultwarden)
- **Source:** https://github.com/dani-garcia/vaultwarden
- **License:** AGPL-3.0
- **Time:** 15 minutes
- **Example VM name:** `my-vaultwarden` (yours will differ; on the VM, `hostname` prints it)
- **Machine-readable:** https://exe-staging.dev/deploy/vaultwarden/manifest.json

## What you get

- Vaultwarden running with signups closed, ready for you to invite yourself.
- The admin panel on a private port behind exe.dev login, with an Argon2-hashed admin password.
- A public front door for Bitwarden apps that refuses /admin and keeps live sync working.
- Nightly backups of the database, attachments and keys, with one checked in a scratch copy.
- Everything starts again after a reboot.

Running on the VM:

- **Vaultwarden 1.37**: The official vaultwarden/server image in Docker Compose, with SQLite and the web vault, port 8080, data in `~/vaultwarden/data`
- **nginx**: The public front door; passes the vault and live sync, refuses /admin, port 8000
- **Nightly backup**: A systemd timer; a consistent copy of the database, attachments and keys, kept two weeks, data in `~/vaultwarden/backups`

How it is reached:

- https://my-vaultwarden.exe.xyz/ (public): The vault, for Bitwarden apps and the web vault, once you choose to open it
- https://my-vaultwarden.exe.xyz:8080/admin (private): The admin panel, behind exe.dev login and the admin password

## Deploy with Shelley

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

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

Or follow the steps below by hand.

Vaultwarden is a small, open-source server for the Bitwarden password
manager. Bitwarden's browser extensions, phone apps, desktop app and CLI
connect to it as they would to Bitwarden's own cloud: shared team vaults,
file attachments, Sends, two-step login, all on a disk you control.

On an exe.dev VM it gets a real, persistent disk and HTTPS with no setup.
Only the vault itself faces the internet: the admin panel stays on a
private port behind your exe.dev login, and if every device can run
Tailscale, the vault can stay off the internet too. Shelley sets it up,
and can take the backups and updates off your hands later.

<figure>
<img src="https://exe-staging.dev/deploy/vaultwarden/vault.png" alt="The Vaultwarden web vault, showing All vaults with two items: a personal login and a Staging database login shared through the Acme Team organization" width="1280" height="800" loading="lazy">
<figcaption>The web vault on a test VM, with a personal item and one shared with the team.</figcaption>
</figure>

> [!WARNING]
> A password manager is the most valuable thing you can host. Your vault
> is encrypted on your devices before it's sent, so the server never sees
> your passwords, but a public server can still be attacked, and you are
> its security team. Use a VM for nothing else, turn on two-step login,
> update promptly, and keep backups off the VM.

## Choose who can reach it

Bitwarden apps talk to the server directly, and they can't sign in to
exe.dev first. So the vault either faces the internet, or it's reachable
only over a private network:

- **Public, hardened** (this guide's default). The vault is at
  `https://my-vaultwarden.exe.xyz/` for anyone to reach, but signups are
  closed, logins are rate-limited per client, and `/admin` isn't served
  there at all. Any device works, no VPN needed. Pick this for a family or
  team with phones and laptops you don't manage.
- **Private, over Tailscale.** The vault is reachable only from devices on
  your [Tailscale](https://tailscale.com/) network, so nobody else can even
  try. Every device needs Tailscale switched on to sync. Pick this if your
  devices already run Tailscale, or if "on the internet" is a deal-breaker.
  Follow [Private with Tailscale](#private-with-tailscale) instead of the
  next step.

Either way, the admin panel at `https://my-vaultwarden.exe.xyz:8080/admin`
is behind exe.dev login, and only people you share the VM with can even
see its password prompt.

## Open the vault

On your computer, make the VM's main port public:

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

Open `https://my-vaultwarden.exe.xyz/` in a private window: you should get
Vaultwarden's sign-in page, not exe.dev's. Signups are closed, so nobody can
make an account until you invite them. `ssh exe.dev share set-private
my-vaultwarden` closes it again.

## Make your account

The admin panel invites people. Get its password; on your computer:

```bash
ssh my-vaultwarden.exe.xyz cat vaultwarden/admin-password
```

1. Open `https://my-vaultwarden.exe.xyz:8080/admin` (sign in to exe.dev if
   asked) and paste the password.
2. In **Users**, enter your email under **Invite User** and click
   **Invite**.
3. Open `https://my-vaultwarden.exe.xyz/`, click **Create account**, and
   use the same email. Choose a long **master password**.

The master password can't be recovered or reset, by you or anyone else:
write it down somewhere safe. Then store the admin password in your new
vault and, if you like, delete `~/vaultwarden/admin-password` from the VM.
Vaultwarden only keeps a hash of it.

Now turn on two-step login: in **Settings → Security → Two-step login**,
click **Manage** next to **Authenticator app**. Then click **View recovery
code** and keep the code with your master password.

## Connect your apps

In any Bitwarden app (browser extension, iOS, Android, desktop), open the
server menu on the login screen (labeled **Logging in on** or
**Accessing**, and set to bitwarden.com), choose **Self-hosted**, and enter
`https://my-vaultwarden.exe.xyz` as the **Server URL**. Then log in with
your email and master password.

The [Bitwarden CLI](https://bitwarden.com/help/cli/) works the same way:

```bash
bw config server https://my-vaultwarden.exe.xyz
bw login you@example.com
bw sync
bw list items --search github
```

Changes sync live: the web vault and desktop apps keep a WebSocket open
through exe.dev's proxy, so an item saved in one shows up in the other
within seconds. Phone apps sync when you open them or pull to refresh.

## Bring your team

Shared passwords live in an **organization**. In the web vault, click
**New organization**, name it, and you're its owner. It starts with a
**Default collection**; add collections for each group of secrets.

To add a teammate:

1. In the organization's **Members**, click **Invite member** and enter
   their email. Under **More settings**, add the collections they may see.
2. Tell them to open `https://my-vaultwarden.exe.xyz/`, click **Create
   account** with that email, and set their own master password. (Without
   [email](#email-optional), nobody gets an invitation message; the invite
   just lets that address sign up.)
3. Back in **Members**, they show under **Needs confirmation**. Choose
   **Confirm** from the menu on their row. Only then can they decrypt the
   shared items.

Removing someone from the organization takes away future access, but they
may have copied what they could already see: change shared passwords when
someone leaves.

> [!NOTE]
> Teammates don't need the exe.dev VM shared with them; the vault is public.
> Sharing the VM (`ssh exe.dev share add`) only lets them reach the admin
> panel's password prompt, so don't, unless they help run the server.

## Lock it down

The install already closes signups, hashes the admin password with
Argon2, keeps `/admin` off the public port, turns off password hints and
rate-limits logins by each client's own address (about ten quick tries,
then one a minute). The rest is up to you:

- **Two-step login for everyone.** In the organization's **Admin Console →
  Settings → Policies**, turn on **Require two-step login**. Owners and
  admins are exempt; other members without it are revoked until they turn
  it on and you restore them in **Members**.
- **Who can make organizations.** Anyone with an account can. To allow only
  you, add `ORG_CREATION_USERS=you@example.com` to
  `~/vaultwarden/vaultwarden.env` and run `docker compose up -d` in
  `~/vaultwarden`.
- **Prefer the apps.** Browser extensions and phone apps ship their own
  code; the web vault's code comes from your server each time you load it.
  Use the web vault for admin chores, not as your daily client.
- **One job per VM.** Anyone with a shell on this VM, including agents
  running there, could tamper with the server. Don't run other apps on it,
  and don't share it with `--root`.
- **Update promptly.** Vaultwarden ships security fixes often (two
  releases in October and November 2026 alone). Watch its
  [releases](https://github.com/dani-garcia/vaultwarden/releases) and
  follow [Update](#update).
- **The admin panel is a second front door.** Settings saved there go into
  `~/vaultwarden/data/config.json` and override `vaultwarden.env`. To turn
  the panel off entirely, remove the `ADMIN_TOKEN` line from
  `vaultwarden.env` and run `docker compose up -d`.

## Keep your vault safe

Everything lives in `~/vaultwarden/data`: the SQLite database, attachments,
Sends, and the key that signs login sessions. Every night a timer saves a
consistent copy of all of it, plus your settings, to
`~/vaultwarden/backups` and keeps two weeks.

A backup on the same disk doesn't survive losing the VM. Copy them off
regularly; on your computer:

```bash
rsync -a my-vaultwarden.exe.xyz:vaultwarden/backups/ ./vaultwarden-backups/
```

The vault items inside are still encrypted with your users' master
passwords, but the files also hold the admin password's hash and any SMTP
password: keep them private. For whole-disk copies in your own S3 bucket,
see exe.dev's [VM backups](/docs/vm-backups).

Also export your vault now and then: **Tools → Export**, format
**.json (Encrypted)**, **Password protected**. That file imports into any
Bitwarden-compatible server, even if this one is gone.

To restore, or to check that a backup restores, see
[Back up and restore](#back-up-and-restore), or ask Shelley.

## Email (optional)

Vaultwarden sends email over SMTP: invitations, email verification,
email as a two-step login method, and new-device alerts. exe.dev's
[email gateway](/docs/send-email) is an HTTP API that only mails you and
your team, so it can't stand in; use a transactional email service's SMTP
settings. Add them to `~/vaultwarden/vaultwarden.env` on the VM:

```bash
SMTP_HOST=smtp.example.com
SMTP_PORT=587
SMTP_SECURITY=starttls
SMTP_FROM=vault@example.com
SMTP_USERNAME=your-smtp-user
SMTP_PASSWORD=your-smtp-password
```

Then `cd ~/vaultwarden && docker compose up -d`, and use **SMTP Email
Settings → Send test email** in the admin panel. With email on, invited
teammates must accept the emailed invitation before they can join.

## Private with Tailscale

This keeps the vault off the internet: Bitwarden apps reach it only from
devices signed in to your Tailscale network, at a `ts.net` address with
Tailscale's own HTTPS certificate. Do this instead of
[Open the vault](#open-the-vault). If you already opened it, close it on
your computer with `ssh exe.dev share set-private my-vaultwarden`.

In the [Tailscale admin console](https://login.tailscale.com/admin/dns),
turn on **MagicDNS** and **HTTPS Certificates**. Then, on the VM, join your
network (Tailscale is preinstalled) and open the login URL it prints. To
join without a login link or an auth key on the VM, use exe.dev's
[Tailscale integration](/docs/integrations-tailscale-wif) instead of
`tailscale up`.

```bash
sudo systemctl enable --now tailscaled
sudo tailscale up --hostname=$(hostname)
```

Serve the vault (nginx's port, so `/admin` stays out) over HTTPS on your
tailnet, and tell Vaultwarden its new address:

```bash
sudo tailscale serve --bg 8000
TS_NAME=$(tailscale status --json | jq -r '.Self.DNSName | rtrimstr(".")')
sed -i "s|^DOMAIN=.*|DOMAIN=https://$TS_NAME|" ~/vaultwarden/vaultwarden.env
cd ~/vaultwarden && docker compose up -d
echo "https://$TS_NAME"
```

Use the printed address as the **Server URL** in your apps, and in
[Make your account](#make-your-account) in place of the `exe.xyz` one. The
admin panel stays at `https://my-vaultwarden.exe.xyz:8080/admin`. Phones
need the Tailscale app connected to sync; they still unlock their offline
copy without it.

## Use your own domain

To serve the vault at, say, `vault.example.com`, point a CNAME at
`my-vaultwarden.exe.xyz` and register it, on your computer, as described in
[custom domains](/docs/cnames):

```bash
ssh exe.dev domain add my-vaultwarden vault.example.com
```

Then set `DOMAIN=https://vault.example.com` in
`~/vaultwarden/vaultwarden.env` and run `docker compose up -d` in
`~/vaultwarden`. Change it before you register security keys or passkeys
for two-step login: they're bound to the domain, and stop working when it
changes. Update the **Server URL** in every app.

## The nuts and bolts

Happy clicking Deploy? You can stop here. These are the same setup steps
Shelley follows, plus the maintenance commands for later. Tested with
Vaultwarden 1.37.5 (web vault 2026.10.1) and Bitwarden CLI 2026.10.1.

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

### Create a VM

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

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

All remaining installation commands run **on the VM**, as `exedev`. They
use `hostname`, so your VM can have any name.

### Get Docker ready

Enable Docker at boot, or exe.dev's on-demand Docker won't restart
Vaultwarden after a reboot. `argon2` hashes the admin password.

```bash
sudo systemctl enable --now docker.service
sudo apt-get install -y argon2
systemctl is-enabled docker.service
```

Expect `enabled`.

### Make the admin password

This makes a random admin password, saves it to
`~/vaultwarden/admin-password`, and gives Vaultwarden only its Argon2 hash
(with the parameters Vaultwarden's own `vaultwarden hash` uses). The
settings file is readable only by you. It won't overwrite an existing one.

```bash
mkdir -p ~/vaultwarden/backups && cd ~/vaultwarden
if [ ! -f vaultwarden.env ]; then
  (
    umask 077
    openssl rand -base64 30 > admin-password
    HASH=$(tr -d '\n' < admin-password | argon2 "$(openssl rand -base64 32)" -e -id -k 65540 -t 3 -p 4)
    cat > vaultwarden.env <<EOF
DOMAIN=https://$(hostname).exe.xyz
ADMIN_TOKEN='$HASH'
EOF
  )
fi
ls -l admin-password vaultwarden.env
grep -c 'argon2id' vaultwarden.env
```

Expect both files with `-rw-------`, and `1`. The single quotes around the
hash matter: they stop its `$` signs from being read as variables.

### Start Vaultwarden

The image tag is pinned; [Update](#update) moves it. Port 8080 is
Vaultwarden itself, which exe.dev's proxy only serves behind your login.

```bash
cat > ~/vaultwarden/compose.yaml <<'EOF'
services:
  vaultwarden:
    image: vaultwarden/server:1.37.5
    container_name: vaultwarden
    restart: unless-stopped
    env_file: vaultwarden.env
    environment:
      SIGNUPS_ALLOWED: "false"
      INVITATIONS_ALLOWED: "true"
      PASSWORD_HINTS_ALLOWED: "false"
      # exe.dev's proxy appends the client's address; rate limits use it.
      IP_HEADER: X-Forwarded-For
    volumes:
      - ./data:/data
    ports:
      - "8080:80"
EOF
cd ~/vaultwarden
docker compose up -d
until curl -fs localhost:8080/alive; do sleep 2; done; echo
docker compose logs | grep -E 'Version|launched'
```

Expect a timestamp in quotes, then `Version 1.37.5` and `Rocket has
launched`.

### Put nginx in front

nginx answers on port 8000, the port `share set-public` publishes. It
passes everything to Vaultwarden except `/admin`, including the WebSocket
for live sync and uploads up to Vaultwarden's 525 MB limit, and passes on
the client address exe.dev's proxy sends.

```bash
sudo tee /etc/nginx/sites-available/vaultwarden >/dev/null <<'EOF'
# exe.dev's proxy -> nginx :8000 (the port you can make public) -> Vaultwarden :8080.
# The admin panel is not served here; it's on the private port 8080.

map $http_upgrade $connection_upgrade {
    default upgrade;
    ''      '';
}

server {
    listen 8000 default_server;
    listen [::]:8000 default_server;
    server_name _;
    client_max_body_size 525m;

    location ^~ /admin {
        return 404;
    }

    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
        proxy_set_header Host $http_host;
        proxy_set_header X-Forwarded-Proto $http_x_forwarded_proto;
        proxy_set_header X-Forwarded-For $http_x_forwarded_for;
        proxy_read_timeout 1h;
    }
}
EOF
sudo rm -f /etc/nginx/sites-enabled/default
sudo ln -sf /etc/nginx/sites-available/vaultwarden /etc/nginx/sites-enabled/vaultwarden
sudo nginx -t
sudo systemctl enable --now nginx
sudo systemctl reload nginx
for u in localhost:8000/alive localhost:8000/admin localhost:8080/admin; do
  echo "$u $(curl -s -o /dev/null -w '%{http_code}' $u)"
done
```

Expect `test is successful`, then `200`, `404` and `200`: the vault is
on port 8000, the admin panel only on 8080.

### Set up nightly backups

The backup uses SQLite's online backup, so Vaultwarden keeps running. It
runs as root because the container writes `data` as root.

```bash
cat > ~/vaultwarden/backup.sh <<'EOF'
#!/bin/bash
# Back up Vaultwarden: a consistent copy of the SQLite database, plus
# attachments, Sends, the session signing key, config.json, and the
# Compose and settings files. Run with sudo.
set -euo pipefail
cd /home/exedev/vaultwarden
stamp=$(date -u +%Y%m%d-%H%M%S)
work=$(mktemp -d)
trap 'rm -rf "$work"' EXIT
mkdir "$work/data"
sqlite3 data/db.sqlite3 ".backup '$work/data/db.sqlite3'"
[ "$(sqlite3 "$work/data/db.sqlite3" 'PRAGMA integrity_check')" = ok ]
for f in attachments sends config.json rsa_key.pem; do
  if [ -e "data/$f" ]; then cp -a "data/$f" "$work/data/"; fi
done
cp -a compose.yaml vaultwarden.env "$work/"
umask 077
tar -C "$work" -czf "backups/vaultwarden-$stamp.tar.gz" data compose.yaml vaultwarden.env
chown exedev: "backups/vaultwarden-$stamp.tar.gz"
find backups -name 'vaultwarden-*.tar.gz' -mtime +13 -delete
echo "backups/vaultwarden-$stamp.tar.gz"
EOF
chmod 755 ~/vaultwarden/backup.sh
```

Schedule it for 03:30 UTC (or so), then take a first backup:

```bash
sudo tee /etc/systemd/system/vaultwarden-backup.service >/dev/null <<'EOF'
[Unit]
Description=Back up Vaultwarden

[Service]
Type=oneshot
ExecStart=/home/exedev/vaultwarden/backup.sh
EOF
sudo tee /etc/systemd/system/vaultwarden-backup.timer >/dev/null <<'EOF'
[Unit]
Description=Back up Vaultwarden every night

[Timer]
OnCalendar=*-*-* 03:30:00
RandomizedDelaySec=30m
Persistent=true

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

Check that the timer has a next run and there's a `vaultwarden-*.tar.gz`
readable only by you. For failures: `journalctl -u vaultwarden-backup`.

### Test a backup

Unpack the newest backup into a scratch directory, count what's in its
database, and start a throwaway Vaultwarden on it, without touching the
running one:

```bash
latest=$(ls -1t ~/vaultwarden/backups/vaultwarden-*.tar.gz | head -n 1)
mkdir /tmp/vw-restore-test
tar -C /tmp/vw-restore-test -xzf "$latest"
sqlite3 /tmp/vw-restore-test/data/db.sqlite3 \
  "SELECT count(*) || ' users' FROM users; SELECT count(*) || ' items' FROM ciphers;"
docker run -d --rm --name vw-restore-test -v /tmp/vw-restore-test/data:/data \
  -p 127.0.0.1:8099:80 vaultwarden/server:1.37.5
until curl -fs localhost:8099/alive; do sleep 2; done; echo
docker stop vw-restore-test
sudo rm -rf /tmp/vw-restore-test
```

Expect counts (`0 users` and `0 items` on a new install), then a
timestamp from the scratch copy.

Installation done. Leave the sharing choice to the owner; continue with
[Choose who can reach it](#choose-who-can-reach-it).

</details>

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

On the VM, `sudo ~/vaultwarden/backup.sh` makes an extra backup and prints
its path. Copy backups off the VM as in
[Keep your vault safe](#keep-your-vault-safe).

### Restore

This replaces the vault with the backup: anything saved since is lost.
Bitwarden apps keep working, since the session key comes back too. Use
your backup's actual filename below.

On the same VM, stop Vaultwarden, keep the current data aside, and unpack
only the backup's `data`:

```bash
cd ~/vaultwarden
sudo ./backup.sh
docker compose down
sudo mv data "data.before-restore-$(date -u +%Y%m%d-%H%M%S)"
sudo tar -C ~/vaultwarden -xzf backups/vaultwarden-20261118-033012.tar.gz data
docker compose up -d
until curl -fs localhost:8080/alive; do sleep 2; done; echo
```

Run `bw sync` or open an app to check your items are there. Keep the
`data.before-restore-*` directory until you're sure.

On a **new** VM, follow [Get Docker ready](#get-docker-ready), then copy
the backup over; on your computer:

```bash
scp vaultwarden-20261118-033012.tar.gz my-vaultwarden.exe.xyz:
```

On the VM, unpack all of it, settings included. If the VM's name changed,
the `sed` points `DOMAIN` at the new `exe.xyz` name (it leaves a custom or
Tailscale domain alone):

```bash
mkdir -p ~/vaultwarden/backups && cd ~/vaultwarden
sudo tar -C ~/vaultwarden -xzf ~/vaultwarden-20261118-033012.tar.gz
sudo chown exedev: compose.yaml vaultwarden.env
sed -i "s|^DOMAIN=https://[a-z0-9-]*\.exe\.xyz$|DOMAIN=https://$(hostname).exe.xyz|" vaultwarden.env
docker compose up -d
until curl -fs localhost:8080/alive; do sleep 2; done; echo
```

Then do [Put nginx in front](#put-nginx-in-front) and
[Set up nightly backups](#set-up-nightly-backups), open the vault as in
[Open the vault](#open-the-vault), and point your apps at the new address
if it changed. Your accounts, items and organizations come back; the old
admin password still works.

</details>

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

Read the [release notes](https://github.com/dani-garcia/vaultwarden/releases)
for the new version, then, on the VM, back up, move the pinned tag, and
restart. Replace `1.37.6` with the version you want:

```bash
cd ~/vaultwarden
sudo ./backup.sh
sed -i 's|vaultwarden/server:.*|vaultwarden/server:1.37.6|' compose.yaml
docker compose pull
docker compose up -d
until curl -fs localhost:8080/alive; do sleep 2; done; echo
docker exec vaultwarden /vaultwarden --version
docker image prune -f
```

Also update the tag in the backup test's `docker run` line. New Bitwarden
app releases sometimes need a newer Vaultwarden, so if an app starts
failing after it updates, update the server first. To roll back,
[restore the backup](#restore) with the old tag: changing the tag alone
won't undo database changes.

</details>

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

On the VM:

```bash
cd ~/vaultwarden
docker compose ps
docker compose logs --tail=100
```

- **An app or `bw` says `invalid or missing authentication`:** that's
  exe.dev's login, not Vaultwarden: the VM is private. Run
  `ssh exe.dev share set-public my-vaultwarden`, or use Tailscale.
- **`Registration not allowed or user already exists`:** signups are
  closed. Invite the address first, from the admin panel or an
  organization.
- **The admin page is a 404:** you're on the public port. Use
  `https://my-vaultwarden.exe.xyz:8080/admin`.
- **The admin password is refused:** paste the password from
  `~/vaultwarden/admin-password`, not the hash. After three quick wrong
  tries, wait five minutes.
- **`Too many login requests`:** the login rate limit; wait a minute.
- **A change to `vaultwarden.env` does nothing:** a setting saved in the
  admin panel wins. Change it there, or remove it from
  `data/config.json`, then `docker compose up -d`.
- **Items don't appear live in the web vault:** check the log for
  `Accepting Rocket WS connection`. If it's missing, check nginx's
  `Upgrade` lines and `sudo nginx -t`.
- **Down after a reboot:** run `sudo systemctl enable --now docker.service`.

</details>

## Frequently asked questions

### Is it safe to put my password manager on the internet?

It's a real trade-off. Bitwarden apps encrypt your vault on your device, so the server only stores ciphertext; a stolen copy is as strong as your master password. But a public server can be attacked directly, and a compromised one could serve a tampered web vault. Use a long master password, two-step login, and prompt updates; prefer the apps to the web vault; and if every device can run Tailscale, [keep it off the internet](#private-with-tailscale).

### Is Vaultwarden the same as Bitwarden?

No. It's an unofficial, community-built server that speaks Bitwarden's API, so Bitwarden's own apps work with it. It's small (about 10 MB of memory here) and includes organizations, attachments, Sends and two-step login. It isn't affiliated with Bitwarden, Inc.; don't take its issues to Bitwarden's support.

### Can I keep the vault private behind exe.dev login and give the apps a token?

No. Bitwarden apps can't sign in to exe.dev, and they use the `Authorization` header for their own tokens, so a [VM token](/docs/https-tokens-for-vms) can't ride along: we tried, and the CLI got 401s. Open the vault port, or use Tailscale.

### Do I need an email server?

No. Without one, you invite people from the admin panel or an organization, and they sign up with the invited address. Add [SMTP](#email-optional) for emailed invitations, email two-step login and new-device alerts.

### What happens if the VM is down?

Bitwarden apps keep an encrypted copy of the vault, so you can still unlock and read your passwords. You can't sync or save changes until it's back.

### How much does it cost?

Vaultwarden is free and open source (AGPL-3.0), and all its features are included. You pay for your [exe.dev plan](https://exe.dev/pricing). It uses very little memory and disk, but keep the VM for the vault alone.


## Related

- [Give agents API access without giving them the keys](https://exe-staging.dev/deploy/agent-secrets.md): Your agents call your APIs. The keys stay with exe.dev, outside the VM.
- [Self-host Uptime Kuma](https://exe-staging.dev/deploy/uptime-kuma.md): A little lookout for your websites. Green bars encouraged.
- [SQLite in production](https://exe-staging.dev/deploy/sqlite.md): One file on a real disk, streamed to your own bucket every second.
- [Deploy a Docker Compose app from GitHub](https://exe-staging.dev/deploy/docker-compose.md): Your compose.yaml on a VM of its own. git push to deploy.
- [Scan your repositories with Codex Security every night](https://exe-staging.dev/deploy/codex-security.md): Nightly AI security scans of your repositories, with no keys on the VM.
- [Review code you don't trust with Open Code Review on a sealed VM](https://exe-staging.dev/deploy/open-code-review.md): An AI code reviewer in a box you copy, seal, and throw away.
