---
title: "Self-host Sure"
description: "Self-host Sure, the open-source personal finance app forked from Maybe, on exe.dev with Docker: private by default, AI without API keys, daily backups."
url: https://exe.dev/deploy/sure
category: "Productivity"
published: 2026-11-19
updated: 2026-11-19
---

# Self-host Sure

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

Personal finance and budgets on your own private VM. AI without API keys.

- **Software:** Sure (https://sure.am)
- **Source:** https://github.com/we-promise/sure
- **License:** AGPL-3.0
- **Time:** 10 minutes
- **Example VM name:** `my-sure` (yours will differ; on the VM, `hostname` prints it)
- **Machine-readable:** https://exe.dev/deploy/sure/manifest.json
- **File:** https://exe.dev/deploy/sure/compose.yml
- **File:** https://exe.dev/deploy/sure/sample-transactions.csv

## What you get

- Sure at your VM's private URL, with web app, worker, PostgreSQL, and Redis, back after a reboot.
- Sign-in through exe.dev's login, with no Sure passwords; the first person to open Sure becomes its admin.
- The AI assistant answering questions about your money through exe.dev's LLM gateway, no API key.
- Free stock prices and exchange rates from Yahoo Finance.
- Daily backups of the database, files, and secrets, with the first one made and listed.

Running on the VM:

- **Sure 0.7.6**: Rails web app and Sidekiq worker, official image in Docker Compose, port 8000, data in `~/sure (.env, backups) and Docker volumes`
- **PostgreSQL 16 and Redis 8**: In the same Compose project, data in `Docker volume sure_postgres-data`
- **exe.dev LLM gateway**: Sure's AI assistant, without an API key

How it is reached:

- https://my-sure.exe.xyz/ (private): Sure, signed in with your exe.dev login; no Sure password
- https://my-sure.exe.xyz/ (shared): Household members you share the VM with, signed in the same way

## Deploy with Shelley

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

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

Or follow the steps below by hand.

Sure is an open-source personal finance app: accounts, net worth,
transactions, budgets, investments, and an AI assistant that answers
questions about your money. It's the community fork of Maybe Finance,
which published its app as open source and then stopped working on it in
2025.

On exe.dev, Sure runs on its own VM with the official Docker images. Its
address is private, and exe.dev's login doubles as Sure's: there are no
Sure passwords, and nobody you haven't shared the VM with gets in. The AI
assistant uses exe.dev's [LLM gateway](/docs/integrations-llm), with no
API key, and Sure backs itself up every night.

## Open Sure

Open the URL Shelley gives you, such as `https://my-sure.exe.xyz/`, and
sign in to exe.dev if you're asked. Sure signs you in with your exe.dev
email. You're its first user, so you get a new household and become the
admin, before anyone else can reach the VM.

A short setup follows: your name, household, and country; then theme,
language, and currency; then your goals. You land on an empty dashboard.

The sign-in comes from a small Rails initializer in the
[Compose file](https://exe.dev/deploy/sure/compose.yml), not from Sure
itself. It trusts the `X-ExeDev-Email` header that exe.dev's proxy adds
and that clients can't fake. Sure's **Sign out** signs you straight back
in; to sign out, sign out of exe.dev.

## Import your transactions

Sure starts with no accounts and no categories. Add an account first:
on the dashboard, click **Add account**, choose **Cash**, then **Enter
account balance**. Name it `Checking`, enter a balance and the date it
applies to (for the sample below, `2500` on 2026-07-31), and pick the
**Checking** subtype.

Then import a CSV file from your bank. To try it with fake data first,
download [sample-transactions.csv](https://exe.dev/deploy/sure/sample-transactions.csv):
91 transactions from August to November 2026, for an account called
`Checking`.

1. Go to **Transactions → Import → Raw Data → Import transactions**.
2. Upload the file. Leave **Account** on **Multi-account import** if your
   file has an account column, as the sample does; otherwise pick the
   account.
3. Match the columns: **Date** `date` with format `YYYY-MM-DD`,
   **Amount** `amount`, **Account** `account`, **Name** `name`, and
   **Category** `category`. The sample's amounts are signed, with income
   positive. Click **Apply configuration**.
4. Click **Next step** past the cleaned data, then **Next** through three
   short pages: keep **Add as new category** for each category, leave tags
   alone, and check that `Checking` maps to your account. Click **Publish
   import**.

The worker imports in the background; refresh after a few seconds. The
sample leaves `Checking` with $12,972.93 and fills the dashboard's
cash flow chart.

<figure>
<img src="https://exe.dev/deploy/sure/dashboard.png" alt="Sure's dashboard with a cash flow chart from income to rent, groceries, food and drink, transportation, and surplus, next to an AI chat answering how much was spent on groceries in October 2026" width="1440" height="900" loading="lazy">
<figcaption>The sample data on Sure's dashboard, with the AI assistant on the right.</figcaption>
</figure>

**Import → Financial Tools & Files** reads exports from Mint, YNAB,
Actual Budget, Quicken (QIF), and Sure itself. Sure can also sync
with banks through a provider such as Plaid or SimpleFIN, in **Settings
→ Bank sync**; each needs your own account with that provider, and most
charge for it.

## Ask the AI assistant

The chat panel on the right says **Enable AI Chats**. Each person turns
it on for themselves. Click it and ask something like:

```text
How much did I spend on groceries in October 2026?
```

With the sample data the answer is $497.05. The assistant looks things up
with Sure's own tools, and it can also change things when you ask: add
transactions, recategorize, and create rules or budgets. Your questions
and what it reads go to the model provider through exe.dev's gateway, and
the chats count against your [LLM allocation](/docs/integrations-llm).

The model is `gpt-6-luna`, set by `OPENAI_MODEL` in `~/sure/.env`.

## Share with your household

On your computer, share the VM:

```bash
ssh exe.dev share add my-sure partner@example.com
```

Send them the URL. When they open it, signed in to exe.dev, Sure adds
them to your household as a **Member** and runs them through the same
short setup. Everyone in a household sees the accounts that are shared
with it; change someone's role in **Settings → Profile Info →
Household**.

`ssh exe.dev share remove my-sure partner@example.com` locks them out
again.

## Scripts and apps

Sure has an HTTP API and a mobile app. Both get past exe.dev's login with
a VM token. On your computer:

```bash
ssh exe.dev ssh-key generate-api-key --vm=my-sure --label=sure-api --exp=90d
```

It prints a token starting with `exe1.`. Keep it in a file only you can
read. Then make a Sure API key in **Settings → API Keys** (**Read Only**
is enough to look), and send both, exe.dev's token in
`X-Exedev-Authorization` and Sure's key in `X-Api-Key`:

```bash
curl https://my-sure.exe.xyz/api/v1/accounts \
  -H "X-Exedev-Authorization: Bearer $EXE_TOKEN" \
  -H "X-Api-Key: $SURE_API_KEY"
```

Expect your accounts as JSON. Without the token, exe.dev answers `401`.
Tools that only speak basic auth can send the token as the password, with
any user name. See [HTTPS tokens for VMs](/docs/https-tokens-for-vms).

The Sure mobile app signs in with an email and password, so first give
yourself a Sure password: open `https://my-sure.exe.xyz/password/edit`,
leave **Current Password** empty, and enter a new one. In the app, enter
`https://my-sure.exe.xyz` as the server, open **Custom proxy headers**,
and add the header `X-Exedev-Authorization` with the value `Bearer
exe1.…`. Then sign in with your exe.dev email and that password.

## Keep your data

Sure writes a full backup every night at 03:30 UTC into `~/sure/backups`:
the database, uploaded files, `.env`, and the Compose file, which is
everything needed to bring Sure back. It keeps 14 days. Keep a copy **off
the VM**. On your computer:

```bash
scp -r my-sure.exe.xyz:sure/backups ./sure-backups
```

The backups include your secret keys and every transaction, so store them
somewhere private. exe.dev's [VM backups](/docs/vm-backups) add a second
layer. To restore, update Sure, or fix something, see below, or ask
Shelley.

## 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.

<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-sure` is taken):

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

All remaining installation commands run **on the VM**, as `exedev`.

### Get Docker ready

Sure's supported way to self-host is Docker Compose. Enable Docker at
boot, or exe.dev's on-demand Docker won't restart Sure after a reboot:

```bash
sudo systemctl enable --now docker.service
systemctl is-enabled docker.service
```

The check should print `enabled`.

### Download the Compose file and write the secrets

[compose.yml](https://exe.dev/deploy/sure/compose.yml) is Sure's
`compose.example.yml` with a few changes for exe.dev: Sure pinned to a
release, the web app on port 8000 (where exe.dev's
[HTTPS proxy](/docs/proxy) sends `https://my-sure.exe.xyz/`),
`RAILS_ASSUME_SSL` because the proxy handles HTTPS, free Yahoo Finance
market data, AI settings, backups owned by `exedev`, and the exe.dev
sign-in, which Compose mounts into the web container as a Rails
initializer. The Compose file is in every backup, so the sign-in comes
back with a restore.

```bash
mkdir -p ~/sure/backups
cd ~/sure
curl -fsSLO https://exe.dev/deploy/sure/compose.yml
```

This writes `.env` **once**. `SECRET_KEY_BASE` and the three
`ACTIVE_RECORD_ENCRYPTION_*` keys encrypt sessions and stored provider
credentials; Sure can't read its data without them, and they must never
change. The AI lines point Sure at the LLM gateway, which needs no real
key. `OPENAI_REASONING_EFFORT=none` lets newer models such as
`gpt-6-luna` call Sure's tools: on the Chat Completions API that Sure
uses with a custom endpoint, they refuse tools unless reasoning is off.
Sure has no setting for it, so a small initializer in the Compose file
adds it to each request.

```bash
cd ~/sure
if [ ! -e .env ]; then
  touch .env && chmod 600 .env
  cat >> .env <<EOF
SURE_IMAGE_TAG=0.7.6-hotfix.1
PORT=8000
APP_DOMAIN=$(hostname).exe.xyz
# Never change these on an existing install. Back them up.
SECRET_KEY_BASE=$(openssl rand -hex 64)
POSTGRES_PASSWORD=$(openssl rand -hex 24)
ACTIVE_RECORD_ENCRYPTION_PRIMARY_KEY=$(openssl rand -hex 32)
ACTIVE_RECORD_ENCRYPTION_DETERMINISTIC_KEY=$(openssl rand -hex 32)
ACTIVE_RECORD_ENCRYPTION_KEY_DERIVATION_SALT=$(openssl rand -hex 32)
# AI through exe.dev's LLM gateway.
OPENAI_ACCESS_TOKEN=exe-llm-gateway
OPENAI_URI_BASE=https://llm.int.exe.xyz/v1
OPENAI_MODEL=gpt-6-luna
OPENAI_REASONING_EFFORT=none
LLM_CONTEXT_WINDOW=128000
EOF
fi
docker compose config -q && echo ok
```

Expect `ok`.

### Start Sure

The first start downloads about 2.5 GB of images and sets up the database,
which takes a minute or two:

```bash
cd ~/sure
docker compose up -d
until curl -fs http://localhost:8000/up >/dev/null; do sleep 5; done; echo up
docker compose ps --format '{{.Service}}: {{.Status}}'
```

Expect `up`, then `web`, `worker`, `db`, and `redis`, all `Up` (the
database and Redis also `healthy`). Requests that don't come through
exe.dev's proxy have no `X-ExeDev-Email` header, so Sure sends them to
its own sign-up page, at an `https://` address because it trusts the
proxy:

```bash
curl -s -o /dev/null -w '%{redirect_url}\n' http://localhost:8000/
```

Expect a URL ending in `/registration/new` that starts with `https://`.
Check that the exe.dev sign-in is loaded:

```bash
cd ~/sure
docker compose exec -T web bin/rails runner '
  puts ApplicationController.ancestors.include?(ExedevLogin::Session) ? "exe.dev sign-in on" : "off"
' 2>/dev/null | tail -1
```

Expect `exe.dev sign-in on`. Don't open Sure through the proxy yet: the
first person it sees becomes the admin, and that should be the owner,
at `https://$(hostname).exe.xyz/`.

### Check the AI

Give the configured model a tool and ask a question that needs it, the
same way Sure's assistant calls it:

```bash
cd ~/sure
docker compose exec -T worker bin/rails runner '
  fn = { name: "get_balance", description: "Balance of an account",
         params_schema: { type: "object", properties: { account: { type: "string" } },
                          required: ["account"] }, strict: false }
  r = Provider::Registry.get_provider(:openai).chat_response(
    "What is the balance of my Checking account?", model: ENV["OPENAI_MODEL"], functions: [fn])
  puts r.success? ? r.data.function_requests.map(&:function_name).join : r.error.message
' 2>/dev/null | tail -1
```

Expect `get_balance`.

### Set up backups

Sure ships its own backup tool. Start the scheduled backup service, then
make a first backup now and list it:

```bash
cd ~/sure
docker compose --profile backup up -d backup
docker compose run --rm backup create
docker compose run --rm backup list
```

Expect a line like `0.7.6/2026-11-19_171331-manual  manual  780K`. Each
backup is a folder in `~/sure/backups/<version>/` with the database dump,
uploaded files, `.env`, the Compose file, checksums, and a `restore.sh`.
`BACKUP_SCHEDULE` and `BACKUP_KEEP_DAYS` in `.env` change the defaults
(`30 3 * * *` UTC, 14 days); run `docker compose --profile backup up -d
backup` after changing them.

</details>

<details id="back-up-and-restore" class="dp-details">
<summary>Restore a backup</summary>

### Roll back on the same VM

This replaces the current database and files with a backup. Stop the app,
restore, and start it again, on the VM:

```bash
cd ~/sure
docker compose run --rm backup list
docker compose stop web worker
docker compose run --rm backup restore latest
docker compose up -d
```

Type `restore` when asked, or name a backup from the list instead of
`latest`, such as `0.7.6/2026-11-19_171331-manual`. If the backup came
from an older Sure, the tool says so: set `SURE_IMAGE_TAG` in `.env` to
that version before `docker compose up -d`.

### Restore onto a new VM

Create a VM and enable Docker as in [Install by hand](#create-the-vm),
then copy one backup folder over. On your computer:

```bash
scp -r ./sure-backups/0.7.6/2026-11-19_171331-manual my-sure-2.exe.xyz:sure-backup
```

On the new VM, `restore.sh` sets up `~/sure` with the backup's Compose
file and `.env`, restores the data, and starts Sure on port 8000:

```bash
sh ~/sure-backup/restore.sh --target ~/sure --port 8000
cd ~/sure
sed -i "s/^APP_DOMAIN=.*/APP_DOMAIN=$(hostname).exe.xyz/" .env
docker compose up -d
docker compose --profile backup up -d backup
```

The `sed` line points Sure's links at the new address. Share the new VM
with your household again; everyone keeps their Sure user, which goes by
their exe.dev email. Stop Sure on
the old VM first (`cd ~/sure && docker compose stop`): two copies syncing
the same bank connections can disconnect them, and scheduled jobs would
run twice.

</details>

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

Read the [release notes](https://github.com/we-promise/sure/releases)
first. Back up, change `SURE_IMAGE_TAG` in `~/sure/.env` to the new
version (such as `0.7.7`), and pull. Database migrations run on their own
when the web app starts. On the VM:

```bash
cd ~/sure
docker compose run --rm backup create
nano .env    # set SURE_IMAGE_TAG=<new version>
docker compose pull
docker compose up -d
docker compose --profile backup up -d backup
until curl -fs http://localhost:8000/up >/dev/null; do sleep 5; done; echo up
```

Open Sure in the browser to check that you're still signed in. The exe.dev
sign-in hooks into Sure's own session code, so a release that changes it
could break it; the web logs then show `exedev_login`. If the new version
misbehaves, [roll back](#back-up-and-restore) to the backup you just made,
with the old `SURE_IMAGE_TAG`.

</details>

<details id="troubleshooting" class="dp-details">
<summary>Troubleshooting</summary>

Start with the logs, on the VM:

```bash
cd ~/sure
docker compose logs --tail=100 web worker
```

- **Sure shows its own sign-in or sign-up page:** the request didn't
  carry exe.dev's `X-ExeDev-Email` header, or the sign-in isn't loaded.
  Use the `https://my-sure.exe.xyz/` address, not a port, and run the
  check in [Start Sure](#create-the-vm). Keep the VM private: on a public
  VM, visitors who aren't signed in to exe.dev reach Sure's sign-up page.
- **"Some data may be out of date … No Sidekiq worker process":** the
  worker isn't running, so imports and syncs wait. `docker compose ps
  worker`, then `docker compose up -d`. A banner right after a restart
  goes away on its own.
- **AI chat says "Failed to generate a response":** the chat shows the
  technical error under the message. Check `OPENAI_MODEL` names a
  gateway model that supports tools. "Function tools with
  reasoning_effort are not supported" means `OPENAI_REASONING_EFFORT=none`
  is missing from `.env`; "Unrecognized request argument supplied:
  reasoning_effort"
  means the model has no reasoning, so empty it. Don't set
  `OPENAI_SUPPORTS_RESPONSES_ENDPOINT`: Sure's Responses mode chains turns
  with stored responses, and the gateway, which keeps no data, answers
  `400`. Don't set `LLM_MAX_RESPONSE_TOKENS` either: Sure then sends
  `max_tokens`, which newer OpenAI models refuse with a `400`.
- **The web app restarts with a database error on a fresh install:** an
  old `sure_postgres-data` volume, from an earlier try with a different
  `POSTGRES_PASSWORD`. If it holds nothing you need, `docker compose down
  -v` deletes it; then `docker compose up -d`.
- **No stock prices or exchange rates:** Sure fetches them from Yahoo
  Finance after the market closes (22:00 UTC on weekdays). If Yahoo
  refuses, add a Twelve Data key in **Settings → Self-Hosting**.
- **After a reboot Sure doesn't come back:** `systemctl is-enabled
  docker.service` must print `enabled`; run `sudo systemctl enable --now
  docker.service`.

</details>

## Frequently asked questions

### Is Sure the same as Maybe Finance?

It's the community fork. Maybe Finance open-sourced its app in 2024, then stopped work on it in July 2025 (its last release, 0.6.0, says the company is pivoting to B2B) and archived the repository. Sure picked up the code the same week and keeps releasing it under the AGPL.

### How much does it cost?

Sure is free and open source. You pay for your [VM plan](https://exe.dev/pricing). AI chats use your exe.dev [LLM allocation](/docs/integrations-llm), including your household's chats. Bank sync providers have their own prices.

### Can Sure connect to my bank?

Yes, through a provider: Plaid, SimpleFIN, Lunch Flow, Enable Banking, and others, set up by the admin in **Settings → Bank sync**. Each one needs your own account with that provider, and most charge for it. Without one, import CSV files, or exports from Mint, YNAB, Actual Budget, or Quicken (QIF).

### Who can see my financial data?

Only you and the people you share the VM with: exe.dev's login is Sure's login, and everyone signed in belongs to one household. Everything is stored on the VM's disk. If you turn on AI chat, your questions and the transactions the assistant looks up go to the model provider through exe.dev's [LLM gateway](/docs/integrations-llm).

### Does the Sure mobile app work with a private VM?

Yes, with a Sure password and a VM token. See [Scripts and apps](#scripts-and-apps).

### Which AI models can I use?

Any model the gateway serves through OpenAI's API that can call tools, such as `gpt-6-luna` (the default here, fast and cheap) or `gpt-6.2-sol` for harder questions. Change `OPENAI_MODEL` in `~/sure/.env` and run `docker compose up -d`. For a model without reasoning, such as `gpt-4.1`, also empty `OPENAI_REASONING_EFFORT`.


## Related

- [Self-host PostgreSQL](https://exe.dev/deploy/postgres.md): Your own Postgres on a real disk, with backups you've actually restored.
- [Deploy a Docker Compose app from GitHub](https://exe.dev/deploy/docker-compose.md): Your compose.yaml on a VM of its own. git push to deploy.
- [Self-host Open WebUI](https://exe.dev/deploy/open-webui.md): A private ChatGPT for you and your team. No API keys.
- [Self-host Vaultwarden](https://exe.dev/deploy/vaultwarden.md): A Bitwarden-compatible password manager for you and your team.
- [Self-host Chatwoot](https://exe.dev/deploy/chatwoot.md): Website chat, email and API conversations in one inbox you own.
- [Cal.diy](https://exe.dev/deploy/cal-diy.md): Open-source scheduling app on exe.dev
