[Blog](https://deploywithox.com/blog) [Guides](https://deploywithox.com/blog#c-guides)

# How to self-host Ghostfolio on your own VPS without Docker

Run Ghostfolio 3.84.2 on your own Ubuntu server with ox: Postgres, Redis, an nx build of the API and Angular client, and the config that ran.

Saurav Sharma Oct 17, 2026 8 min read

On this page

- [What you need](https://deploywithox.com/blog/self-host-ghostfolio#what-you-need)
- [The steps](https://deploywithox.com/blog/self-host-ghostfolio#steps)
- [The ox.toml, line by line](https://deploywithox.com/blog/self-host-ghostfolio#config)
- [Postgres and Redis](https://deploywithox.com/blog/self-host-ghostfolio#services)
- [Updates and backups](https://deploywithox.com/blog/self-host-ghostfolio#updates)
- [Frequently asked questions](https://deploywithox.com/blog/self-host-ghostfolio#faq)

To self-host Ghostfolio you need an Ubuntu server, a fork of the Ghostfolio repo with one `ox.toml` file added, and six variables. In our run the first deploy took about 7 minutes, and ox set up the Postgres database and the Redis cache that Ghostfolio uses.

**How we tested** On Oct 17, 2026, ox deployed Ghostfolio 3.84.2 from commit [`b9832e8e`](https://github.com/ghostfolio/ghostfolio/commit/b9832e8eff7f8d5bf471fc02ef3ff3766f6bfe67) on a fresh DigitalOcean server with 8 vCPUs and 16 GB of memory. The run then redeployed it, backed it up and rebooted the server. Then a separate test agent, one that did not write the config, signed in, added an account with a cash balance and saw it after a reload, and checked the app's services and its backup.

[Ghostfolio](https://github.com/ghostfolio/ghostfolio) is open source wealth management software. You record your accounts and your trades in stocks, ETFs and crypto, and it shows how your portfolio is doing. Its README says it is made for personal use in continuous operation, and the code is under the AGPL v3. It is a TypeScript app in an nx workspace: a NestJS server answers the API under `/api/v1` and serves the Angular client. Postgres holds the data through Prisma, and Redis holds the cache and the job queues.

ox deployed Ghostfolio 3.84.2 (commit b9832e8e) on Oct 17, 2026 on a fresh DigitalOcean server with 8 vCPUs and 16 GB of memory; the first deploy took 7 minutes and a redeploy took 5 minutes.

- **First deploy:** 7 minutes, from adding the project until the app passed the run's first checks.
- **Redeploy of the same commit:** 5 minutes, until the app passed the checks again.
- **Server:** DigitalOcean, 8 vCPUs and 16 GB of memory (`s-8vcpu-16gb`), with this app alone on it. Every one of the 85 apps we deployed ran on this one size, so it was not picked for this app.
- **Memory in use after the reboot:** 1532 MB of 15986 MB, for the whole server: Ubuntu, the app and its staging copy, its services, Caddy and the ox agent. On a server with no apps, ox's tests on real servers hold the agent to 40 MB or less and Caddy to 50 MB or less.
- **Services ox runs for it:** `postgres`, `redis`.
- **Source:** [github.com/ghostfolio/ghostfolio](https://github.com/ghostfolio/ghostfolio) at 3.84.2, commit [`b9832e8e`](https://github.com/ghostfolio/ghostfolio/commit/b9832e8eff7f8d5bf471fc02ef3ff3766f6bfe67).

The Ghostfolio landing page before signing in

The Ghostfolio welcome overview after signing up

The Ghostfolio Accounts page listing the new account Brokerage with 1,000.00 USD

## What you need

- An Ubuntu LTS server. The run used the size listed in the facts above and measured the memory there.
- A GitHub account to fork `ghostfolio/ghostfolio`, and an ox account, which signing in with GitHub makes.
- No mail server and no outside account. Ghostfolio has no mail setup and no passwords, because you sign in with a Security Token. Its README also lists optional CoinGecko API keys and an experimental OpenID Connect sign-in. Neither was tested.

## The steps

Add a server in the ox dashboard, copy the install command it shows, with its own token inside, and run it as root on your server. It installs the ox agent and Caddy.

Fork `ghostfolio/ghostfolio` on GitHub and check out the commit the facts above give, which is release 3.84.2. Put the `ox.toml` shown below at the root of the fork, commit it and push. The deploy added no other file.

On your laptop, write a file named `ghostfolio.env` with the six keys from the variables section. `ACCESS_TOKEN_SALT` and `JWT_SECRET_KEY` each take a random string of your own, and `openssl rand -hex 32` makes one. The other four take references, explained below. With the [ox CLI](https://deploywithox.com/docs/cli) signed in, run:

Shell

```bash
ox new <you>/ghostfolio
ox review ghostfolio --from-file ghostfolio.env --wait
```

The review saves the values and starts the first deploy, and `--wait` prints the run's log until it ends. In the browser the same two steps are New project and the review screen, which the [quickstart](https://deploywithox.com/docs/quickstart) walks through.

When the deploy is green, open the address ox shows for the project. It redirects to a language path such as `/en/`. Press Get Started, then Create Account, and accept the terms with Continue. A dialog shows your Security Token once. Press Copy to clipboard, which turns on the Create Account button, then press that, and you land on the welcome page signed in. To sign in again, press Sign in in the header and paste the token. The test agent also pasted a wrong one, and Ghostfolio answered "Oops! Incorrect Security Token." Ghostfolio has no email setup, so keep the token somewhere safe.

Ghostfolio's README says the first user made on a fresh install gets the ADMIN role, and its code does the same. Sign-up is open by default, so make your own account before you share the address. The run's own check had already made the first user, so the test agent's account was a regular one and the admin screens were not tested.

The test agent then opened Accounts in the top menu, pressed the round plus button at the bottom right, and saved an account called Brokerage in USD with a 1,000.00 cash balance. It was still listed after a reload.

The run served Ghostfolio on its preview address only. A domain of your own was not part of it, and the [domains page](https://deploywithox.com/docs/operate/domains) covers how ox adds one. Prices and symbol search, importing and exporting transactions, and the app on a phone were not tested either.

## The ox.toml, line by line

TOML

```toml
# Ghostfolio (NestJS API + Angular client in an nx workspace, prisma).
# Install, start and node come from detection.

[app]
# Answers 200 only when postgres and redis both answer.
health = "/api/v1/health"

[build]
# The repo names its production build build:production (no "build").
commands = ["npm run build:production"]
# As its Docker entrypoint: migrate, then load the reference data.
migrate = "npx prisma migrate deploy && npx prisma db seed"

[services]
postgres = {}
redis    = {}   # caches and the job queues
```

The file names only what ox cannot read from the repo. It has no install command, no start command and no Node version. ox took the install from `package-lock.json`, the start from the repo's own `start` script, and Node 22 from the repo's `.nvmrc`.

- `health` is Ghostfolio's health route. Its README says it checks the connection to the database and to Redis, so it answers only when both do. ox waits for a success from it before traffic moves to a new release.
- `commands` runs `npm run build:production`. The repo has no script named `build`, so the config names the one it has. It builds the NestJS API and the Angular client with nx, and it is the long part of a first deploy.
- `migrate` does what Ghostfolio's Docker entrypoint does at start. `prisma migrate deploy` applies the pending schema changes, then `prisma db seed` adds three tags (DRAFT, EMERGENCY_FUND and EXCLUDE_FROM_ANALYSIS) and skips any that exist, so it is safe on every deploy.
- `postgres` and `redis` under `[services]` ask ox for a database and a cache. Postgres is shared with other projects on the server, each with its own database and user. Redis runs only for this project.

There are no workers. Ghostfolio runs its queues and its cron inside the API process, and the test agent saw the job processor finish a job in the app's own log.

Shell

```bash
ACCESS_TOKEN_SALT
JWT_SECRET_KEY
ROOT_URL
REDIS_HOST
REDIS_PORT
REDIS_PASSWORD
```

`ACCESS_TOKEN_SALT` keys the hash Ghostfolio stores for each Security Token. `JWT_SECRET_KEY` signs the session tokens it hands out, which last 180 days. The run set both to fixed test strings, so make your own.

`ROOT_URL` is `${PUBLIC_URL}`, which ox fills in with the project's address. Ghostfolio uses it for callback URLs and external links. The three Redis keys are `${redis.host}`, `${redis.port}` and `${redis.password}`, and ox fills them from the Redis it started, with a password it generated. See [variables](https://deploywithox.com/docs/operate/variables) for how references work.

`DATABASE_URL` is not in the list because ox provides it. The repo's example env file also names `POSTGRES_USER` and a few other keys, but they belong to its Docker Compose setup, and the app's code never reads them.

## Postgres and Redis

The run also deployed a staging copy beside production, with a second Redis of its own, and the memory figure above counts both copies. The README notes that the Redis part of the health check can take up to five seconds. ox waits up to two minutes for a health route to answer.

## Updates and backups

To move to a newer release, merge its tag into your fork and push, or run `ox deploy ghostfolio --wait`. The migrate step applies the schema changes before the new release takes traffic. Read `CHANGELOG.md` in the repo first. The run redeployed the same commit, so an upgrade between versions was not tested.

Backups need no setup. The run's backups held a daily Postgres dump, one from Back up now, one ox took before the migrate, and a daily Redis archive. Run `ox backups ghostfolio` to list them. A restore was not tested. The [backups page](https://deploywithox.com/docs/operate/backups) covers keeping copies in an S3 bucket.

## Frequently asked questions

### Do I need Docker to self-host Ghostfolio?

No. The README points to Docker images and a compose file, but Ghostfolio is a Node.js app that npm builds. ox builds it from your fork on the server and runs it as a system service, with Postgres and Redis installed beside it. There is no image to pull, and an update is a push.

### How do I make the first Ghostfolio account?

Open the address, press Get Started, then Create Account. Ghostfolio shows a Security Token once, and there is no password or email. Copy it and keep it, because it is the only way back in. The first account made on a fresh install gets the ADMIN role, as the README says.

### Does Ghostfolio need Redis?

Yes. Ghostfolio uses Redis for its cache and its job queues, and its health route answers only when both Postgres and Redis do. ox starts a Redis for the project with its own password, and the three REDIS variables point the app at it.

### How much memory does self-hosted Ghostfolio use?

The facts above show what the whole server used after the run's reboot. That counts Ghostfolio, its staging copy, two Redis instances, Postgres, Caddy and the ox agent, and the build was not running then. ox takes any server from 1 GB up and says so when memory is why an app stopped.

### Can I change ACCESS_TOKEN_SALT later?

Changing it locks people out. Ghostfolio stores only an HMAC of each Security Token, keyed with this salt, and sign-in hashes what you paste the same way. A new salt gives new hashes, so old tokens stop matching. Set it before the first deploy and keep it. The run never changed it.

New to running apps on your own server? [How ox self-hosts your apps](https://deploywithox.com/self-hosting) shows what ox sets up on your server.

On this page

- [What you need](https://deploywithox.com/blog/self-host-ghostfolio#what-you-need)
- [The steps](https://deploywithox.com/blog/self-host-ghostfolio#steps)
- [The ox.toml, line by line](https://deploywithox.com/blog/self-host-ghostfolio#config)
- [Postgres and Redis](https://deploywithox.com/blog/self-host-ghostfolio#services)
- [Updates and backups](https://deploywithox.com/blog/self-host-ghostfolio#updates)
- [Frequently asked questions](https://deploywithox.com/blog/self-host-ghostfolio#faq)
- [Do I need Docker to self-host Ghostfolio?](https://deploywithox.com/blog/self-host-ghostfolio#faq-docker)
- [How do I make the first Ghostfolio account?](https://deploywithox.com/blog/self-host-ghostfolio#faq-login)
- [Does Ghostfolio need Redis?](https://deploywithox.com/blog/self-host-ghostfolio#faq-redis)
- [How much memory does self-hosted Ghostfolio use?](https://deploywithox.com/blog/self-host-ghostfolio#faq-memory)
- [Can I change ACCESS_TOKEN_SALT later?](https://deploywithox.com/blog/self-host-ghostfolio#faq-salt)

Written by Saurav Sharma

Builds ox. Writes about running apps on servers you own, without Docker and without a platform bill.

[Older post How to self-host GlitchTip without Docker on your own VPS](https://deploywithox.com/blog/self-host-glitchtip) [Newer post How to self-host Ghost on your own VPS without Docker](https://deploywithox.com/blog/self-host-ghost)

## Keep reading

- Guides [Self-Hosted Open-Source Apps Deployed with ox: All 85](https://deploywithox.com/blog/self-hosted-open-source-apps-deployed-with-ox) ox deployed 85 open-source apps from pinned commits on fresh servers, with no Docker. The stacks, services, deploy times and a table of every app. Saurav Sharma Oct 17, 2026 16 min read
- Guides [How to self-host AFFiNE on your own VPS without Docker](https://deploywithox.com/blog/self-host-affine) Run AFFiNE v0.27.4 on your own Ubuntu server with ox: Postgres with pgvector, Redis, a Rust and Node build, and an admin made from two variables. Saurav Sharma Oct 17, 2026 12 min read
- Guides [How to self-host Akaunting on your own VPS without Docker](https://deploywithox.com/blog/self-host-akaunting) Run Akaunting 3.2.4 on your own Ubuntu server with ox: PHP, MariaDB, a scheduler and the first company and admin made on deploy, from the config that ran. Saurav Sharma Oct 17, 2026 10 min read

## Deploy to a server you own

ox sets up systemd, Caddy and PostgreSQL on your Ubuntu server and deploys on every push. Free for your first project.

[Sign up with GitHub](https://deploywithox.com/login/github) [Read the docs](https://deploywithox.com/docs)