---
title: "Deploy Passbolt CE | (Just Updated) Open Source Team Password Manager, Admin Setup Link Generated"
description: "Passbolt CE open source password manager, admin setup link, data kept"
category: "Other"
url: https://railway.com/deploy/passbolt-ce-or-just-updated-open-source-
---

# Deploy Passbolt CE | (Just Updated) Open Source Team Password Manager, Admin Setup Link Generated

Passbolt CE open source password manager, admin setup link, data kept

**[Deploy Passbolt CE | (Just Updated) Open Source Team Password Manager, Admin Setup Link Generated on Railway](https://railway.com/template/passbolt-ce-or-just-updated-open-source-)**

Machine-readable deploy manifest (JSON, validated by TemplateCI): https://railway.com/deploy/passbolt-ce-or-just-updated-open-source-/manifest.json

- **Creator:** SuperSlowSloth
- **Category:** Other

## Template content

### passbolt

- **Image:** ghcr.io/bon5co/passbolt-railway:5.18.0@sha256:ac0aff94b494484c2f1dd7a8e1b1096d0c4e020672931ce9aafce1bf49571f3b
- **Health check:** /healthcheck/status
- **Public domain:** Yes

### mariadb

- **Image:** mariadb:11.8@sha256:6422478cb8e159f080fb1d8ccf65101e26fe51385787fde7d16c3b165a331f15
- **Start command:** `/bin/sh -c 'set -e; M=$(cat /sys/fs/cgroup/memory.max 2>/dev/null || echo max); if [ "$M" != max ]; then B=$((M / 2 / 1048576)); [ "$B" -lt 128 ] && B=128; else B=512; fi; export MARIADB_DATABASE=passbolt MARIADB_USER=passbolt; echo "[railway] uid=$(id -u) innodbBufferPoolMB=$B owner=$(stat -c %u:%g /var/lib/mysql)"; exec docker-entrypoint.sh mariadbd --datadir=/var/lib/mysql/data --innodb-buffer-pool-size=${B}M --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci'`

## Documentation

# Deploy and Host Passbolt CE on Railway

**Built for an LLM agent to deploy and use.** The deploy form has no fields to fill: the database password and a setup secret are generated, the server key, JWT keys and database sit on volumes, and the first administrator's setup link is derived from the generated secret so a deploying agent can compute it without reading logs. Passbolt CE is the open-source, self-hosted team password manager: every secret is encrypted in the browser with OpenPGP, so the server stores only ciphertext.

## About Hosting Passbolt CE

This template runs two services: **passbolt** (the upstream non-root Passbolt CE 5.18.0 image through a thin wrapper, with a volume at `/data` holding the server GPG key, the JWT keypair and avatars) and **mariadb** (MariaDB 11.8 on a volume at `/var/lib/mysql`, reached over the private network). Both survive redeploys, so the server key, every user and every stored secret persist. A first deploy runs the database migrations and generates the keys, which takes a few minutes before the healthcheck turns green.

**What the wrapper fixes.** Upstream keeps the server GPG key and JWT keys inside the container filesystem, so a Railway redeploy without a volume there would regenerate them and lock every user out of their stored secrets. The wrapper symlinks those paths into the `/data` volume. It also creates the first administrator at first boot from variables, with a setup link that is the same on every boot, instead of a console command someone has to run in a shell.

**Using it.** Open the setup link, install the Passbolt browser extension and finish the setup there: generating a user's OpenPGP key happens in the browser, so no script can complete that last step for you. Everything before it is automatic and checked by the snippet below. The administrator's address is the placeholder `admin@example.com`; to use your own, add an `ADMIN_EMAIL` variable on the `passbolt` service before the first deploy. Outgoing email is not configured; Passbolt needs it to invite more users, so add the upstream `EMAIL_TRANSPORT_DEFAULT_*` variables described in the Passbolt documentation.

### Agent contract

- Public URL: `https://RAILWAY_PUBLIC_DOMAIN` (the generated domain of the `passbolt` service)
- Private URL: `http://passbolt.railway.internal:8080`
- Credentials: the variable `PASSBOLT_SETUP_SECRET` on the `passbolt` service. It is not a login: it derives the administrator's setup link (the user id and token are the first 32 hex digits of sha256 of `SECRET:uid` and `SECRET:token`, shaped as UUIDs, as the snippet computes). The Passbolt user's own key and passphrase are created in the browser during setup.
- Auth: every Passbolt API call needs a signed-in session or a JWT issued after setup; there is no static API key. A write with no credential answers 403 and one with a wrong bearer token answers 401. Public sign-up is closed: registering a user answers 403.
- Health: `GET /healthcheck/status` returns 200

```bash
#!/bin/sh
# needs: RAILWAY_PUBLIC_DOMAIN, PASSBOLT_SETUP_SECRET (variables of the passbolt service); also curl, sha256sum, cut, printf. Read-only apart from refused requests.
R="https://$RAILWAY_PUBLIC_DOMAIN"; J="Content-Type: application/json"
# the first administrator's setup link: user id and token are the first 32 hex digits of sha256 of SECRET:uid and SECRET:token, shaped as a v4 UUID
u() { h=$(printf '%s' "$PASSBOLT_SETUP_SECRET:$1" | sha256sum | cut -c1-32); printf '%s-%s-4%s-a%s-%s' "$(echo "$h" | cut -c1-8)" "$(echo "$h" | cut -c9-12)" "$(echo "$h" | cut -c14-16)" "$(echo "$h" | cut -c18-20)" "$(echo "$h" | cut -c21-32)"; }
UID_=$(u uid); TOKEN=$(u token)
n=0; until [ "$(curl -s -o /dev/null -w '%{http_code}' "$R/healthcheck/status.json")" = 200 ]; do n=$((n+1)); [ "$n" -le 90 ] || break; sleep 5; done
curl -s -o /dev/null -w "health: %{http_code}\n" "$R/healthcheck/status.json"
# the setup link the deployer opens in a browser with the Passbolt extension: a valid token answers 200 with the pending admin, a wrong token is refused
curl -s -w "\nsetup link: %{http_code}\n" "$R/setup/start/$UID_/$TOKEN.json" | sed -n 's/.*"username":"\([^"]*\)".*/setup user: \1/p;s/^setup link: /setup link: /p'
curl -s -o /dev/null -w "setup link wrong token: %{http_code}\n" "$R/setup/start/$UID_/ffffffff-ffff-4fff-afff-ffffffffffff.json"
# refusals: Passbolt authenticates every API call with a signed-in session, so a write with no credential or a wrong one is refused
curl -s -o /dev/null -w "write without key: %{http_code}\n" -X POST -H "$J" -d '{"name":"x","secrets":[]}' "$R/resources.json"
curl -s -o /dev/null -w "write wrong key: %{http_code}\n" -X POST -H "$J" -H "Authorization: Bearer not-a-token" -d '{"name":"x","secrets":[]}' "$R/resources.json"
curl -s -o /dev/null -w "public signup: %{http_code}\n" -X POST -H "$J" -d '{"username":"intruder@example.com"}' "$R/users/register.json"
```

Expected output against a fresh deploy (measured on a Railway deploy of this template):

```text
health: 200
setup user: admin@example.com
setup link: 200
setup link wrong token: 400
write without key: 403
write wrong key: 401
public signup: 403
```

The refusals are the contract: `write without key: 403`, `write wrong key: 401` and `public signup: 403`. `setup link: 200` shows the administrator exists and the derived link is valid, and `setup link wrong token: 400` shows a guessed token is rejected.

## Why Deploy Passbolt CE on Railway?

Railway is a singular platform to deploy your infrastructure stack. Railway will host your infrastructure so you don't have to deal with configuration, while allowing you to vertically and horizontally scale it.

By deploying Passbolt CE on Railway, you are one step closer to supporting a complete full-stack application with minimal burden. Host your servers, databases, AI agents, and more on Railway.

- **Agent-ready** - no deployer fields, a contract block, and one script that proves the instance is healthy, the administrator setup link is valid, and unauthenticated writes and sign-ups are refused.
- **Keys survive redeploys** - the server GPG key and JWT keys live on a volume, so users keep access to their stored secrets.
- **Administrator from variables** - the first admin is created at boot with a stable setup link, with no shell step.
- **Sign-up closed** - Passbolt only registers users an administrator invites.
- **Pinned** - the upstream image is pinned by digest and the wrapper by tag and digest.

## Common Use Cases

- **Team password manager** - share credentials with per-user and per-group permissions, end-to-end encrypted in the browser.
- **Self-hosted alternative to a hosted password vault** - your encrypted data stays in a database you control.
- **Secrets sharing for an engineering team** - API keys, server logins and licences with an access audit trail.
- **Agent credential store** - give an automation a place to fetch shared secrets through the Passbolt API after setup.

## Dependencies for Passbolt CE Hosting

- The passbolt and mariadb services with their volumes, created by the template. A custom domain is optional; the application URL follows the Railway domain.

### Deployment Dependencies

- [Passbolt repository](https://github.com/passbolt/passbolt_api)
- [Passbolt documentation](https://www.passbolt.com/docs/)
- [Wrapper image source](https://github.com/bon5co/passbolt-railway)


## Similar templates

- [Rocky Linux](https://railway.com/deploy/rocky-linux) — Hosted Rocky Linux 9 workspace with SSH and persistent storage. 🚀
- [Foundry Virtual Tabletop](https://railway.com/deploy/X5tR6G) — Self-hosted virtual tabletop for role-playing games (license required)
- [Double Commander in your browser](https://railway.com/deploy/double-commander-in-your-browser) — The Double Commander file manager in the cloud, from any device

Open this page in a browser: https://railway.com/deploy/passbolt-ce-or-just-updated-open-source-
