Wallos: Take Control of Your Subscription Sprawl

Subscription creep is real. Between streaming services, SaaS tools, domain registrations, VPS providers, cloud storage, and a half-dozen other recurring charges, most people have no clear picture of what they’re actually spending every month. Commercial apps like Rocket Money and Copilot will track this for you — but they monetize your financial data to do it.

Wallos is the self-hosted alternative: a PHP/SQLite web app that tracks your subscriptions locally, alerts you before renewals hit, handles multiple currencies, and never touches an external server unless you ask it to. It has 7,600+ GitHub stars and ships 190+ releases — this is not an abandoned side project.

What Wallos Tracks

At its core, Wallos is a database of recurring expenses with a dashboard on top. Each entry gets:

• Service name and logo — fetched automatically from the web or uploaded manually
• Cost and currency — with automatic exchange rate conversion to your base currency
• Billing cycle — monthly, annual, or any other frequency
• Next payment date — used to drive reminders
• Payment method — track which card or account gets charged
• Category — for spending breakdowns
• Notes — whatever context helps you remember what this is and why you have it

The dashboard shows monthly and annual totals, spending by category, upcoming payments, and a running tally of how much you’d save if you cancelled paused subscriptions. It’s a simple thing done well.

Architecture

Wallos is a PHP 8.2+ application backed by SQLite. The entire database is a single file. The web server is nginx or Apache with PHP-FPM. No external services required — everything runs in the Docker container with a couple of mounted volumes.

The simplicity is a feature. Backup is “copy the SQLite file.” Migrations are a single PHP endpoint. There’s no Postgres to tune, no Redis to worry about, no background worker queue. For an app whose job is to track subscriptions, this is the right level of complexity.

Deploying with Docker Compose

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

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

Two volumes: the database directory and the logos directory. Both need to persist across container updates — don’t skip them.

After the container starts, visit http://your-server:8282 and complete the initial setup wizard. Then — and this step is easy to miss — run the database migration endpoint:

http://your-server:8282/endpoints/db/migrate.php

This creates the schema. Without it, the app won’t function correctly.

Behind Traefik

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

networks:
  traefik:
    external: true

services:
  wallos:
    image: bellamy/wallos:latest
    container_name: wallos
    environment:
      - TZ=America/New_York
    volumes:
      - ./db:/var/www/html/db
      - ./logos:/var/www/html/images/uploads/logos
    networks:
      - traefik
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.wallos.rule=Host(`subs.yourdomain.com`)"
      - "traefik.http.routers.wallos.entrypoints=websecure"
      - "traefik.http.routers.wallos.tls.certresolver=letsencrypt"
      - "traefik.http.services.wallos.loadbalancer.server.port=80"
    restart: unless-stopped

The container listens on port 80 internally — Traefik routes to that, not 8282. Drop the ports: mapping entirely when running behind a reverse proxy.

Notifications

Wallos supports seven notification channels for renewal reminders:

Configure these in Settings → Notifications. You can set a lead time (e.g., notify 7 days before renewal) and test each channel before relying on it. Wallos sends a preview notification so you can verify delivery without waiting for an actual renewal.

Important: notifications require cron jobs. The container runs several scheduled tasks:

These are configured inside the container automatically. If notifications aren’t arriving, verify the container timezone is correct via TZ and check the container logs for cron output.

For a homelab already running Gotify or ntfy, wiring up Wallos notifications takes about two minutes. It’s a genuinely useful integration — getting a push notification a week before your annual AWS bill hits gives you time to review whether you still need whatever you provisioned.

Multi-Currency

If you pay for services in multiple currencies — USD for AWS, EUR for some European SaaS, GBP for something else — Wallos handles it. Each subscription stores its native currency and amount; the dashboard converts everything to your base currency for totals.

Exchange rates update automatically via the Fixer API. The free tier is sufficient for personal use. Setup:

1. Get a free API key from fixer.io
2. Go to Settings → Currencies and add your API key
3. Add the currencies you need
4. Trigger the first rate fetch by changing your base currency and changing it back

After that, rates update daily at 2 AM automatically.

Known issue: The get_monthly_cost API endpoint has reported problems when multiple currencies are in use. The dashboard itself displays correctly; it’s only that specific API endpoint that’s affected.

Statistics and Reporting

The statistics page breaks down spending across several dimensions:

• Monthly trend — time-series view of spending over time
• Category breakdown — which categories are consuming the most budget
• Payment method breakdown — which card or account has the most recurring charges on it
• Annual projections — what your current subscriptions will cost over a year
• Savings calculator — aggregates the cost of paused/disabled subscriptions to show what you’d recover by cancelling them

Budget targets can be set per category. The statistics page shows your current spend against the target. This is useful for the homelab spending category specifically — it’s easy to justify one more VPS, one more S3 bucket, one more monitoring SaaS, until you add them all up.

Logo Fetching

Each subscription entry can display a logo, which makes the dashboard considerably more readable at a glance. Wallos can fetch logos automatically by searching the web — type the service name, pick from the results. For services it can’t find, you can upload an image manually.

Logos persist in the mounted ./logos volume, so they survive container updates. The automatic fetching is a small convenience that makes a real difference to the dashboard UX.

REST API

Wallos has a documented REST API at api.wallosapp.com. It’s PHP endpoint-based rather than a conventional REST framework, but it’s functional for integration and automation.

Authentication uses API keys generated in Settings → API.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Get all subscriptions
curl "https://subs.yourdomain.com/endpoints/api/v1/subscriptions/get_subscriptions.php" \
  -H "X-API-KEY: your-api-key"

# Filter by category
curl "https://subs.yourdomain.com/endpoints/api/v1/subscriptions/get_subscriptions.php?category=1" \
  -H "X-API-KEY: your-api-key"

# Filter by payment method
curl "https://subs.yourdomain.com/endpoints/api/v1/subscriptions/get_subscriptions.php?payment_method=2" \
  -H "X-API-KEY: your-api-key"

# Filter by state (active, cancelled, paused)
curl "https://subs.yourdomain.com/endpoints/api/v1/subscriptions/get_subscriptions.php?state=active" \
  -H "X-API-KEY: your-api-key"

The API returns JSON with subscription details, costs, and dates. Useful for pulling Wallos data into a homepage dashboard (Homarr, Heimdall, Dasherr), a Grafana panel, or an n8n automation workflow.

Import and Export

Export: Wallos exports subscriptions as CSV or JSON from the Settings menu. CSV works well for importing into spreadsheets or other tools. JSON is better for moving between Wallos instances.

Import: CSV import lets you bulk-add subscriptions, which is helpful when first setting up. Prepare a CSV with the expected column headers (available in the export for reference) and import in one shot rather than entering dozens of entries manually.

Community members have built conversion scripts for importing from specific tools into Wallos. If you’re migrating from a commercial subscription tracker, check the GitHub discussions for a matching script.

Backup

The entire Wallos dataset is one SQLite file in ./db/wallos.db. Back this up however you back up other important files:

1
2
3
4
5

# Simple daily backup via cron
0 3 * * * cp /opt/wallos/db/wallos.db /backup/wallos/wallos-$(date +\%Y\%m\%d).db

# Or rsync to NAS
0 3 * * * rsync -av /opt/wallos/db/ nas:/backups/wallos/

SQLite in WAL (Write-Ahead Logging) mode is safe to copy while the container is running — you don’t need to stop the container or lock the database for a consistent backup.

Keep the ./logos directory in your backup too, since those don’t regenerate automatically.

Comparison with Alternatives

The key differentiator for Wallos vs. commercial tools is data sovereignty. Rocket Money and Copilot work by connecting to your bank accounts via Plaid — they see your transaction history to automatically detect subscriptions. That’s convenient, but it means your financial data lives on someone else’s infrastructure and is used to train their models and inform their business.

Wallos is manual. You add subscriptions yourself. That’s slightly more friction at setup, but your data never goes anywhere. For a homelab operator who already cares enough about privacy to self-host their services, this is the natural choice.

Use Cases

Personal subscription audit. Start by adding every subscription you can think of, then check your bank and credit card statements for anything you missed. Most people find at least one or two forgotten subscriptions they haven’t touched in months. Wallos makes the ongoing picture visible rather than requiring periodic manual audits.

Homelab cost tracking. Create a “homelab” category and track VPS costs, domain registrations, DNS providers, CDN, monitoring SaaS, backup storage, and any other infrastructure spend. When you’re deciding whether to spin up another service, you can see the current total and make an informed decision.

Annual renewal planning. Some subscriptions bill annually — it’s easy to forget a large charge is coming. Set a 30-day notification lead time for annual subscriptions and you’ll always have warning before the charge hits.

Payment method hygiene. When you change credit cards, Wallos shows you exactly which subscriptions are on the old card. Filter by payment method and you have a migration checklist.

Gotchas

The database migration step is required. First-time setups need to visit /endpoints/db/migrate.php after the container starts. Skipping it produces confusing errors. This should be part of every setup guide but often isn’t.

Container updates don’t auto-apply. If the dashboard shows an outdated version after pulling a new image, delete and recreate the container rather than just restarting it.

Cron jobs are essential. Notifications and currency updates require the scheduled tasks to run. If you’re using a container management tool that doesn’t persist the cron schedule, verify it’s working after setup by checking for log output.

The Fixer API free tier has rate limits. Daily rate updates are well within the limit for personal use, but if you’re hitting the API manually during setup and testing, space out your requests.

Webhook format changed in v4.x. If you’re upgrading from an older version and have custom webhooks configured, verify they still work after the update — the payload format was simplified in v4.

The Bottom Line

Wallos does one thing: tells you what you’re paying for and when. It does it without ads, without selling your data, without requiring a bank connection, and without a subscription of its own. The Docker setup is straightforward, the notification system covers every reasonable delivery channel, and the backup story is as simple as a SQLite file.

If you’ve ever wondered whether you’re still using all the services you’re paying for, Wallos is the fastest way to find out — and the most privacy-respecting way to keep track going forward.