# Wallos: a self-hosted subscription tracker you run in one Docker container

> Wallos is a PHP and SQLite web app for tracking recurring payments. It installs with a single docker run command, but it expects you to schedule cron jobs and to keep its database volume intact.

**ellite/Wallos** — Wallos: Open-source, self-hostable personal subscription tracker. Visualize your recurring expenses, manage your budget, and save money.

- Repository: https://github.com/ellite/Wallos
- Website: https://wallosapp.com
- Stars: 8,539 · Forks: 428
- Language: PHP
- License: GPL-3.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/ellite-wallos

## What Wallos tracks that a spreadsheet does not

A spreadsheet can hold a list of subscriptions. What it does not do is recalculate the next payment date on a schedule, convert amounts into one currency, and push a reminder before the charge lands. Wallos is built around those three jobs. The README describes it as an open-source, self-hostable web application for managing finances, and the feature list names subscription management, category management, multi-currency support, currency conversion through the Fixer API, statistics, and notifications over email, Discord, Pushover, Telegram, Gotify and webhooks.

The intended user is someone with enough recurring payments that a plain list stops being useful, and enough technical comfort to run a container or a PHP host. That second condition is not optional. Wallos is not a hosted product with a signup page; the README points at a demo at demo.wallosapp.com with the credentials demo and demo, reset every two hours, so you can look before you install. Everything after that happens on your own machine.

## How Wallos is put together: PHP, SQLite and scheduled scripts

The repository is a PHP application, and the Dockerfile builds it from php:8.3-fpm-alpine. Nginx serves the app inside the container on port 80, and the PHP extensions installed during the build are pdo, pdo_sqlite, calendar, gd, intl and zip. Storage is SQLite. In the baremetal instructions the README tells you to rename /db/wallos.empty.db to /db/wallos.db, and in Docker the db directory is mounted as a volume at /var/www/html/db.

Several things that look like background features are actually cron jobs. The README lists updatenextpayment.php, updateexchange.php, sendcancellationnotifications.php, sendnotifications.php, sendverificationemails.php, sendresetpasswordemails.php, checkforupdates.php, storetotalyearlycost.php and generaterecommendations.php, each with its own schedule. The Docker image copies a crontab file to /etc/cron.d/cronjobs, so the container handles this itself. On baremetal you add those lines with crontab -e. If the jobs do not run, notifications and payment dates go stale even though the web interface still loads.

The Dockerfile also sets pm.max_children to 15 and pm.max_requests to 500 in the PHP-FPM pool, and writes an ini file raising upload_max_filesize and post_max_size to 256M. Those are the limits you hit first if you upload many logos or run the app for several users.

## Installing Wallos with docker run or docker-compose

The README gives a single docker run command. It mounts two host paths, one for the SQLite database and one for uploaded logos, sets the timezone, and publishes container port 80 on host port 8282. Replace the two /path/to/config paths with real directories before running it.

```bash
docker run -d --name wallos -v /path/to/config/wallos/db:/var/www/html/db \
-v /path/to/config/wallos/logos:/var/www/html/images/uploads/logos \
-e TZ=Europe/Berlin -p 8282:80 --restart unless-stopped \
bellamy/wallos:latest
```

After the container starts, open http://your-host:8282 in a browser. The README states that migrations run automatically on the registration page, so the first thing you should see is account creation rather than an error. The README also documents an optional healthcheck override for Docker versions below 25 or for faster startup reporting, added as --health-cmd=NONE to the same command.

The compose file in the repository is the same setup in YAML form, with optional OIDC variables commented out. A minimal version keeps the two volumes and the timezone:

```yaml
services:
  wallos:
    container_name: wallos
    image: bellamy/wallos:latest
    ports:
      - "8282:80/tcp"
    environment:
      TZ: 'America/Toronto'
    volumes:
      - './db:/var/www/html/db'
      - './logos:/var/www/html/images/uploads/logos'
    restart: unless-stopped
```

For a baremetal install the README requires NGINX or Apache plus PHP 8.3 with curl, dom, gd, intl, openssl, sqlite3, zip, mbstring and fpm enabled. You clone the repository into your web root, rename the empty database file, open the app so migrations run, and then add the cron entries. Upgrades on baremetal mean pulling the files again and running the migration endpoint:

```bash
php /var/www/html/endpoints/db/migrate.php
```

On Docker, upgrading means pulling a newer bellamy/wallos tag and recreating the container with the same two volume mounts.

## Where Wallos is the wrong tool

The README does not describe a mobile application. The feature list mentions a mobile view, which is a responsive web layout, not an app you install from a store. If you want subscription reminders on a phone without opening a browser, the notification integrations are the mechanism, and they depend on the cron jobs running.

The second limitation is operational. SQLite plus a mounted directory means backups are your responsibility. There is no documented export command in the README, and no documented rollback procedure if a migration goes wrong. The repository has a migrations directory and a migrate.php endpoint, and the README says migrations run automatically, but it does not say what happens to a database created by an older version. Take a copy of the db volume before pulling a new image tag.

The third is that some features reach outside your server. The README states that currency conversion integrates with the Fixer API, that logo search queries the web, and that AI recommendations work with ChatGPT, Gemini or a local Ollama instance. The docker-compose.yaml includes an optional SSRF_ALLOWLIST variable that overrides the allowlist in the Admin UI, which tells you the maintainers treat outbound requests as something to constrain. If you want a tracker that never talks to a third party, you are choosing which of these to leave off.

## Wallos compared with a spreadsheet or a hosted tracker

The honest alternative for many people is the spreadsheet they already have. A spreadsheet costs nothing, needs no server, and is trivially portable. What it lacks is the scheduled recalculation of next payment dates and the push notification before a charge. Wallos trades server maintenance for those two behaviours. If you have fewer than a handful of subscriptions, the trade is not worth it.

The other alternative is a hosted subscription tracker, where someone else runs the database and you get an app. The difference is where the data lives and who can read it. Wallos is self-hosted, and the README frames data privacy as a consequence of that: your financial data stays on your own server. That is a real difference, not a marketing one, but it moves the burden of uptime, backups and upgrades onto you. Wallos is also GPL-3.0 licensed, which matters if you plan to modify and redistribute it rather than just run it.

## Maintenance cost and licensing for Wallos

The repository is not archived, and the last push was on 2026-09-10, the same day as the v5.7.1 release. Releases v5.7.0 and v5.6.0 landed within the preceding week. That tells you the project is moving, and it also means upgrade instructions matter more than they would for a frozen tool.

The baremetal upgrade path is manual: re-download or git pull, check the prerequisites again, then run the migration endpoint. Nothing in the README automates that for you. The Docker path is a tag pull plus container recreation, which is easier but still requires the volumes to be pointed at the same directories, or you start from an empty database. The Dockerfile also pins the base image to php:8.3-fpm-alpine, so a future PHP requirement change would show up as a new image rather than something you opt into.

Wallos is licensed GPL-3.0. Running it on your own server for your own subscriptions is the ordinary case. If you intend to modify it and distribute the result, the licence terms apply to what you distribute, and that is a question for someone qualified to read them rather than for this article.

## Conclusion

Adopt Wallos if you already run Docker or a PHP 8.3 host and want subscription data on hardware you control. Skip it if you need a mobile app or a hosted service, because the README describes neither. Before committing, verify that the db and logos volumes persist across upgrades and that the cron jobs listed in the README are actually running.

## FAQ

### What is Wallos?

Wallos is an open-source, self-hostable web application for tracking recurring subscriptions and expenses. The README lists subscription management, categories, multi-currency support, statistics and notifications as its features, and the project is written in PHP.

### Are Wallos safe to use?

The README's safety argument is that self-hosting keeps your financial data on your own server. Two caveats follow from the same document: currency conversion uses the Fixer API, logo search queries the web, and AI recommendations can call ChatGPT, Gemini or a local Ollama instance, so outbound requests exist unless you turn those features off.

### Are Wallos hard to use?

The Docker install is one docker run command with two volume mounts, and migrations run automatically when you first open the registration page. The baremetal route is more work: PHP 8.3 with nine required modules, a renamed database file, and nine cron entries added by hand.

### Who invented Wallos?

The README does not name an author or maintainer. It links to a Discord server, a GitHub Sponsors page and a contributor graph, and the repository owner is ellite.

## Sources

- [ellite/Wallos on GitHub](https://github.com/ellite/Wallos)
- [License: GPL-3.0](https://github.com/ellite/Wallos/blob/main/LICENSE)
- [Project website](https://wallosapp.com)
- [README](https://github.com/ellite/Wallos/blob/main/README.md)
- [Releases](https://github.com/ellite/Wallos/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ellite-wallos