DEV Community

John
John

Posted on

Best Spliit Alternatives for Self-Hosting: When Splitwise, a Spreadsheet or a Plain-Text Ledger Wins

#selfhosted #homelab #opensource

Self-host Spliit only if the group splitting the bills is stable, recurring and at least four people, and you already run Postgres with nightly backups for something else. For a single holiday, a two-person household or a group that scatters after one weekend, the hosted instance at spliit.app, Splitwise, a shared spreadsheet or three lines in a plain-text ledger will settle the same money with none of the container, database, domain and backup upkeep. Spliit is a genuinely good open source Splitwise alternative, but it is a web app with no accounts and no notifications, so the person who hosts it inherits every support request from everyone else in the group.

TL;DR by reader profile:

  • Solo developer with an established homelab (you already run a Docker host, Postgres and restic snapshots for a flatshare of four): self-host Spliit, because the marginal cost is one container, one database and one subdomain on infrastructure you already patch.
  • Occasional trip organiser (one ten day ski trip a year, eight people, half of them on iPhones you will never configure): use the hosted spliit.app instance or Splitwise, because uptime and link sharing matter more to you than owning the rows.
  • Flatshare with fixed monthly bills (rent, power, internet, same four names every month): use a shared spreadsheet with one row per bill, because your split rarely changes and a sheet needs no reverse proxy.
  • Plain-text accounting user (you already keep hledger or beancount files in Git): keep using the ledger, because one split posting per shared expense reuses a workflow you trust and version control you already back up.
  • Nextcloud owner (you run Nextcloud for files and calendars anyway): install Cospend in Nextcloud instead, because you inherit real user accounts, sharing and existing backups rather than adding a second stack.
  • Privacy-driven self-hoster (you will not put who you travelled with on a third-party server): self-host Spliit, but plan the network exposure first, because its group URLs are the only access control it ships with.

The central tradeoff is simple: Spliit gives you ownership of the data and none of the convenience of an account system, so you are trading a managed service's uptime and push notifications for a container you patch, a database you back up and a link every group member must not lose.

Table of contents

What Spliit actually does, and what it leaves out on purpose

Spliit is an open source expense splitter: you create a group, add the people in it, log expenses, and it tells you who owes whom. Sébastien Castiel maintains it as a Next.js application backed by PostgreSQL, published as a Docker image, with a free hosted instance at spliit.app. It covers the core Splitwise job well: splits by shares, exact amounts or percentages, expense categories, running balances and a suggested set of reimbursements that clears the debts in the fewest transfers.

The omissions are deliberate, and they decide whether self-hosting makes sense for you.

  • No user accounts at all: access to a group is the group URL, which contains a random identifier, so there is nothing to log into, no password reset, and no per-member permissions.
  • No notifications: Spliit sends no email and no push reminders, so nobody is nudged to settle up and you chase people in your group chat anyway.
  • No money movement: it records that Sam owes you 42 EUR, it does not transfer anything, so you still settle in your banking app.
  • Identity lives in the browser: the active participant is remembered client side, so opening the same group on a phone and a laptop means selecting who you are again.
  • No multi-currency conversion: you set a currency symbol for the group, so a trip mixing EUR and CHF receipts needs you to convert before entering the amount.

Everything else in this article compares alternatives against that specific shape: strong splitting mathematics, zero account management, and a database you now own.

Which Spliit alternatives are genuinely comparable?

Four things compete with a self-hosted Spliit container, and only two of them are apps. Ruling out the wrong comparison early saves you a weekend: a budgeting tool like Actual Budget or Firefly III tracks your own money over time, it does not compute who owes whom inside a group, so it is not an alternative here no matter how good it is.

Option What it is Where it beats a self-hosted Spliit
spliit.app The maintainer's own hosted instance of the same code Identical features and identical group URLs, with somebody else running Postgres and the upgrades
Splitwise Hosted commercial service with accounts, apps on iOS and Android, and a paid tier Real logins, push reminders and a phone app your group already has installed
Nextcloud Cospend A group expense app installed into an existing Nextcloud instance Reuses Nextcloud users, sharing and your existing backup job instead of adding a second stack
Shared spreadsheet One Google Sheets or Excel file with a row per expense Editable by five people at once, no deployment, and everyone already knows how to use it
Plain-text ledger An hledger, Ledger or Beancount file in Git Auditable history, arbitrary reporting, and version control you already have

Hosted mobile-first tools such as Tricount and Settle Up sit beside Splitwise: no self-hosting option, so relevant only if you conclude you should not self-host at all. The rest of this article works through when each of these five wins on the merits.

When is hosted Splitwise the better answer than a Spliit container?

Splitwise wins whenever the people in the group matter more than the rows in the database. It has native iOS and Android apps, accounts with password recovery, and reminders that arrive without you sending them. Spliit has none of those, so the moment your group includes someone who will not keep a URL safe, the hosted service is doing work your container cannot.

  • One-off groups: a single ten day trip with eight people does not justify a Postgres instance you will still be patching in two years, and Splitwise costs you nothing to start.
  • Groups that must not depend on you: if you are away with no laptop when your home server reboots into a failed migration, nobody can add an expense, and the people chasing money are your friends.
  • Phone-first participants: Splitwise is installed from the App Store or Play Store in one tap, while Spliit is a web app you have to explain, including how to add it to a home screen.
  • Nagging and settle-up prompts: Splitwise pushes reminders, and its paid tier adds extras billed per person per year, so check the current figure before comparing it against your hosting bill.

Choose Splitwise unless you have a concrete reason not to, typically that you refuse to put your travel and flatmate history on a third-party service. If that is your reason, the hosting decision is separate from the app decision: a self-managed VPS, a home server, a NAS or a managed option all run the same image. Yundera is a managed Personal Cloud Server, built on CasaOS, that runs self-hosted apps as Docker containers on a server dedicated to the user.

Can a shared spreadsheet replace Spliit for a four-person flatshare?

For fixed monthly bills, yes, and it usually wins. A flatshare paying rent, power, internet and water splits the same four amounts between the same four names every month. That is a table, not an application. Six columns get you there: date, description, payer, amount, split rule, and a per-person column each. One =SUMIF(D:D,"Sam",E:E) style total per flatmate gives you the balance Spliit would have computed, and Google Sheets or a file in a Nextcloud instance handles four people editing at once.

  • Setup time: a working sheet takes about 15 minutes, against a container, a Postgres volume, a subdomain and a backup job for Spliit.
  • Zero access control problems: you share the sheet with four Google accounts or four Nextcloud users, and you can revoke one of them without invalidating everyone else's link.
  • Arbitrary rules: one flatmate paying 30 percent of the internet because they work from home is one edited formula, where an app makes you express it as shares or exact amounts on every single expense.
  • Free-form history: you can add a column for the meter reading or the landlord's invoice number, which no expense splitter will model for you.

The sheet breaks down in three specific cases: high expense volume, where 60 grocery receipts a month makes manual entry miserable; phone entry, where typing into a spreadsheet at a supermarket till is genuinely worse than Spliit's form; and trust, where one careless paste overwrites a formula and nobody notices for a month. If two of those three apply to you, stop defending the sheet.

When does a plain-text ledger beat Spliit outright?

When you already keep one. If your finances live in an hledger, Ledger or Beancount file in Git, shared expenses are just postings, and you get per-person balances from a tool you trust with your own money. A grocery run you paid for, split three ways, is four lines in shared.journal:

2026-03-14 Supermarket
    expenses:food           20.00
    assets:owed:sam         20.00
    assets:owed:alex        20.00
    assets:bank            -60.00
Enter fullscreen mode Exit fullscreen mode

Then hledger -f shared.journal bal assets:owed prints exactly what Spliit's balances screen would show, and hledger reg assets:owed:sam gives the full history behind one number.

  • Version control for free: every change is a commit with an author and a timestamp, which is stronger provenance than any expense app gives you, and your existing Git remote is the backup.
  • Reporting you cannot get otherwise: monthly shared spend by category, or a 3 year trend across two different flatshares, is one command with --monthly and a period filter.
  • Multi-currency done properly: ledger tools price commodities, so a trip mixing EUR and CHF is recorded at the rate on the day rather than converted by hand before entry.
  • No infrastructure at all: a text file has no Postgres to upgrade, no image to patch and no URL to leak.

The cost is brutal and obvious: nobody else in the group will ever touch it. You become the single point of entry for every receipt, and settling up means exporting a summary your flatmates will believe. Use a ledger when the group is you plus people who are happy to send you photos of receipts, and never when four people all want to log their own spending.

Spliit vs Nextcloud Cospend: which self-hosted splitter fits a homelab?

If you have already decided to self-host, this is the real comparison, and it is decided by what is already running on your box. Cospend is a Nextcloud app by Julien Veyssier, installed from the Nextcloud app store into an instance you already operate. Spliit is a standalone Next.js container plus its own PostgreSQL database.

Dimension Spliit Cospend in Nextcloud
What you add One app container, one Postgres container, one volume, one subdomain One app inside an existing Nextcloud, no new container and no new database
Identity No accounts, the group URL is the access token Nextcloud users and groups, plus link access for people without an account
Backups A new pg_dump target you must remember to add to your backup job Covered by whatever already backs up Nextcloud's database and data directory
Mobile A web app you add to the home screen yourself Web interface plus the MoneyBuster companion app on Android
Failure blast radius Breaking Spliit breaks only expense splitting A bad Nextcloud upgrade takes files, calendars and expenses down together

The rule is uncomplicated. Running Nextcloud already? Install Cospend and save yourself a stack. Not running Nextcloud? Do not deploy one just to get expense splitting, because you would be adding a large PHP application and its cron requirements to solve a four person grocery problem. Spliit is the smaller commitment in that case, on a VPS, a home server, a NAS or Yundera, and its single purpose means an upgrade can only break the one thing.

What does Spliit's no-login group URL model mean for you?

It means the URL is the password, and it behaves like a password you cannot change. Anyone holding the group link can read every expense, add new ones, edit amounts and delete history. There is no revocation, no per-member permission, and no record of which participant made a change, so a wrong edit is indistinguishable from a malicious one.

  • The link spreads the way links spread: it lands in WhatsApp, Telegram and iMessage threads, and some chat platforms fetch previews for URLs they see, so the address leaves your group's control the moment you paste it.
  • Putting a login in front breaks the feature: wrapping Spliit in Authelia, Authentik or basic auth means every flatmate needs credentials on your server, which removes the one thing that made sharing painless.
  • A VPN only works if everyone joins it: binding Spliit to Tailscale is the cleanest protection, and it also means installing Tailscale on your sister's phone before she can log a 12 EUR taxi.
  • Search engines are not the threat, carelessness is: add a robots.txt deny and no indexer will crawl the group, but a screenshot of the browser with the address bar visible undoes that in one post.
  • The data is more sensitive than it looks: dates, amounts, descriptions and names together show who you travelled with and when, which is exactly the history a hosted service would also hold.

Practical stance: treat each group URL as a bearer token with an unlimited lifetime. If that sentence makes you uncomfortable for your particular group, Splitwise accounts or Cospend's Nextcloud users are the honest answer, not a reverse proxy trick.

Does Spliit survive contact with non-technical group members?

Usually, but you become the support desk, and that cost is the one people underestimate. Spliit's entry form is clean and the maths is invisible, so the app itself is not the problem. The problem is everything around it: getting it onto phones, keeping the link findable, and answering questions at 23:00 on the second night of a trip.

  • Home screen installation is platform specific: on iOS it is Safari, Share, then Add to Home Screen, and on Android Chrome it is the menu then Install app, so you write two sets of instructions for a group of eight.
  • Every device asks who you are again: the active participant is stored per browser, so someone switching from their laptop to their phone selects their own name a second time and often picks the wrong one first.
  • A lost link is a support ticket for you: there is no password reset page to send them to, only you re-sending the URL, and you will re-send it more than once.
  • Nothing reminds anyone: with no email or push notification, expenses go unlogged for 4 or 5 days and get entered from memory, which is where the wrong amounts come from.
  • Your uptime is now social: a failed container restart during a holiday is not a homelab incident, it is three people unable to log what they just paid for.

The realistic test is one question: if two of the group refuse to enter their own expenses, you are the only user, and a plain-text ledger or a spreadsheet does the same job with no deployment. Spliit earns its keep only when at least 3 people in the group actually type into it.

Are the receipt scanning and S3 document features worth wiring up?

Only for high volume paper receipts, and only if you have already accepted a third party in the loop. These are optional features, disabled until you add environment variables, so check the repository's .env.example for the exact names your version expects before copying anything.

  • Receipt attachments need object storage, not a volume: the document feature is switched on with a flag such as NEXT_PUBLIC_ENABLE_EXPENSE_DOCUMENTS and then expects S3 style credentials, bucket, region and endpoint, so you are running MinIO or Garage locally or paying a provider like Backblaze B2 or Cloudflare R2.
  • Scanning sends the image off your server: the extraction feature uses an OpenAI API key, so every scanned receipt, with its merchant, date and total, leaves the machine you deliberately chose to own.
  • The cost is per call, not per month: vision requests are billed per token, so the shape is a small charge each time somebody scans, which is fine for 20 receipts on a trip and worth measuring before you leave it enabled for a year.
  • Your backup surface doubles: a pg_dump no longer captures everything, because the images live in the bucket, and a restore that brings back expenses with broken attachment links is a half restore.
  • Manual entry is faster than you think: typing 9.80 and the word Taxi takes about 10 seconds, which is the honest benchmark any scanner has to beat.

Recommendation: leave both flags off for a flatshare with fixed bills. Turn them on for expense claims you may need to justify later, where the photo of the receipt is the point and the split is secondary.

How much maintenance does a Spliit stack really cost over three years?

Not much per event, but the events never stop, and three years is long enough that you hit every category at least once. Budget a few hours a year in total, distributed badly: mostly 10 minute jobs plus one bad evening.

Recurring task Realistic cadence over 3 years What happens if you skip it
Pull a new app image and let Prisma migrations run on start Every 1 to 2 months if you track releases You drift far enough behind that a later upgrade jumps several schema changes at once
PostgreSQL major version upgrade At least once, since majors ship yearly and support windows run about 5 years Your database container eventually runs an unsupported major with no security fixes
Verify a restore, not just that the backup ran Once a quarter, 15 minutes with pg_restore into a scratch database You discover on the day you need it that you have been dumping an empty volume
Domain and certificate upkeep Renewal yearly, certificate automation checked after each reverse proxy change The group URL breaks and nobody can reach the app until you notice
Fix an upgrade that changed configuration Expect one occurrence, an evening's work The container restarts into a loop and the group has no expense tracker that week

Compare that honestly against the alternatives. Splitwise and spliit.app cost you zero of these. A spreadsheet costs you zero. A Git-backed ledger costs you a push. If the phrase "one bad evening every 18 months" annoys you rather than interests you, that is a real signal, not laziness.

Where should you run Spliit, and who holds the data?

If the reason you are self-hosting is data sovereignty, be precise about it, because Spliit's group data is small and its exposure requirements are large. The database holds names, dates, amounts and descriptions for everyone in the group, not just you, so you are now the custodian of other people's records.

What self-hosting actually buys you:

  • No third-party account tied to your social graph: the group exists only in your Postgres volume, so nobody profiles who you travel with.
  • Jurisdiction you choose: a home server or a VPS in a country you picked keeps the data under one legal regime instead of whichever one the vendor operates in.
  • Retention on your terms: a group from 2023 stays until you run a DELETE, and no product decision archives it for you.
  • Exit without negotiation: you can pg_dump the whole thing today and move it anywhere.

Where to run it is a separate question from whether to. A home server behind CGNAT needs a tunnel or a relay before anyone outside your LAN can load the app. A VPS solves reachability and moves the disk to a provider. A NAS running Docker works if the unit tolerates a Postgres write load. Yundera is another option alongside those three.

Before you host it for other people, confirm:

  • The group URL travels over HTTPS only: no plain HTTP fallback on the reverse proxy.
  • Backups are encrypted and offsite: one copy on the same disk is not a backup.
  • You can name your recovery time: how long from dead host to working group URL, in hours.
  • The group knows it is your server: they should know who holds the data before they add a single expense.

Top comments (0)