ExpenseOwl is a free, open source finance & accounting project written in HTML and released under MIT. It has 1,510 GitHub stars, 151 forks and 58 open issues, and was last pushed 11 months ago. On this registry it ranks #20 of 34 tracked projects in Finance & Accounting, with 5 head-to-head comparisons available. It gained 1 stars over the last 3 tracked days.

What is ExpenseOwl?

What it is

ExpenseOwl is self-hosted expense tracker for personal finance. It lives in open-source homelab and finance-management ecosystem. It uses Go and HTML. It is MIT licensed. It ships as self-contained binary and Docker container. It focuses on quick monthly look at expenses. It avoids accounts, budgeting, and other features found in broader finance trackers.

It solves problem of overcomplicated expense tools. Many GitHub projects offer accounts and complex budgeting. ExpenseOwl keeps core flow short: add income or expense with date, amount, and category. It then shows category pie chart and cashflow for month. It suits single-user home lab deployment, where user wants local data, no internet interaction, and simple visualization.

Key capabilities

  • Quick expense and income entry requires only date, amount, and category. Recurring transactions support income and expenses.
  • Custom categories, currency symbols, and start date are set in app settings. Optional tags classify transactions. Tags appear when at least one transaction uses them.
  • Main dashboard shows monthly category pie chart and cashflow indicator. Clicking category excludes it from chart; clicking again adds it back. Cashflow shows total income, total expenses, and balance in red or green.
  • Table view lists monthly or all expenses chronologically. Transactions can be deleted, and holding shift skips confirmation. Browser search can find names or tags.
  • Settings support reordering, adding, and removing categories. CSV export and CSV import from virtually anywhere are available.
  • Interface includes light and dark themes. Front end can be installed as PWA on desktop and mobile, while backend remains self-hosted.
  • Self-contained binary and container image avoid internet interaction. Multi-architecture Docker container supports persistent storage.

Who uses it and how

  • Home lab users run single-user instance for personal expense tracking.
  • Users track monthly spending by category and check income, expenses, and balance.
  • Users add recurring income and expenses, then review them in dashboard pie chart and table view.
  • Users export data as CSV, or import CSV from other sources, for backup or migration.
  • Users install PWA on smartphone or desktop for front-end access, with self-hosted backend, while Kubernetes users have community-contributed spec sample.

Getting started

Docker is recommended: run tanq16/expenseowl:main with port 8080 and volume expenseowl:/app/data, or use compose with image tanq16/expenseowl:main and persistent /app/data. Binary releases create data directory in current working directory and start app at http://localhost:8080; source build uses go build ./cmd/expenseowl, while Kubernetes uses community-contributed spec sample.

When to use it — and when not to

Use ExpenseOwl when need simple self-hosted monthly expense tracking in home lab. Avoid it when need accounts, complex budgeting, or multi-user design. Self-hoster must run Docker image or binary and manage persistent /app/data; facts show 58 open issues and no contributor count.

project readme (upstream, from github) — read inline


ExpenseOwl


Release GitHub Release Docker Pulls

Why Create This? • Features • Screenshots
Installation • Usage • Contributing


ExpenseOwl is an extremely simple self-hosted expense tracking system with a modern monthly pie-chart visualization and cashflow showcase.


Why Create This?

There are a ton of amazing projects for expense tracking across GitHub (Actual, Firefly III, etc.). They're all incredible! I just don't find them fast and simple. They offer too many features I never use (like accounts or complex budgeting). Don't get me wrong! They're amazing when complexity is needed, but I wanted something dead simple that gives me a quick monthly look at my expenses. NOTHING else!

So, I created this project and I use it in my home lab for expenses. The primary intention is to track spending across your categories in a simplistic manner. No complications, searching, budgeting. This is not a budgeting app; it's for tracking.

Features

Core Functionality

  • Quick expense/income add (only date, amount, and category are required)
  • Single-user focused (mainly for a home lab deployment)
  • Recurring transactions for both income and expenses
  • Custom categories, currency symbols, and start date via app settings
  • Optional tags for further classification
  • Beautiful interface with both light and dark themes
  • Self-contained binary and container image to ensure no internet interaction
  • Multi-architecture Docker container with support for persistent storage
  • PWA support for using the app on smartphone

Visualization

  1. Main dashboard - category breakdown (pie chart) and cashflow indicator
    • Click on a category to exclude it from the pie chart; click again to add it back
    • Visualize the month's breakdown without considering some categories like Rent
    • Cashflow shows total income, total expenses, and balance (red or green based on +ve or -ve)
  2. Table view for detailed expense listing
    • View monthly or all expenses chronologically and delete them (hold shift to skip confirm)
    • Use the browser to search for a name or tags if needed
    • Tags show up if at least one transaction uses it;
  3. Settings page for configurations and additional features
    • Reorder, add, or remove custom categories
    • Select a custom currency symbol and a custom start date
    • Exporting data as CSV and import CSV from virtually anywhere

Progressive Web App (PWA)

The front end of ExpenseOwl can be installed as a Progressive Web App on desktop and mobile devices (i.e., the back end still needs to be self-hosted). To install:

  • Desktop: Click the install icon in your browser's address bar
  • iOS: Use Safari's "Add to Home Screen" option in the share menu
  • Android: Use Chrome's "Install" option in the menu

Screenshots

Dashboard Showcase:

Desktop View Mobile View
Dark
Light
Expand this to see screenshots of other pages
Desktop View Mobile View
Table Dark
Table Light
Settings Dark
Settings Light

Installation

The recommended installation method is Docker. To run the container via CLI, use the following command:

docker run --rm -d \
  --name expenseowl \
  -p 8080:8080 \
  -v expenseowl:/app/data \
  tanq16/expenseowl:main

To use Docker compose, use this YAML definition:

services:
  expenseowl:
    image: tanq16/expenseowl:main
    restart: unless-stopped
    ports:
      - 5006:8080 # change 5006 to what you want to expose on
    volumes:
      - /home/tanq/expenseowl:/app/data # change dir as needed
Expand this to see additional execution options

Using the Binary or Building from Source

Download the appropriate binary from the project releases. The binary automatically sets up a data directory in your CWD, and starts the app at http://localhost:8080.

To build the binary yourself:

git clone https://github.com/tanq16/expenseowl.git && \
cd expenseowl && \
go build ./cmd/expenseowl

Kubernetes Deployment

This is a community-contributed Kubernetes spec. Treat it as a sample and review before deploying to your cluster. Read the associated readme for more information.

Usage

Once deployed, use the web interface to do everything. Access it through your browser:

  • Dashboard: http://localhost:8080/
  • Table View: http://localhost:8080/table
  • Settings: http://localhost:8080/settings

[!NOTE] This app does not include authentication, so deploy carefully. I don't want to add half-baked authentication, so use Authelia, or equivalent as needed. ExpenseOwl works well with a reverse proxy like Nginx Proxy Manager too and is intended for homelab use only.

Conventions

Since writing the app, I've found a ton of ways applications handle expenses. Release v4.0 solidifies the conventions I will continue to maintain the app in.

  • Expenses are categorized by a -ve value, while income or reimbursement (designated by the Report as gain checkbox) are +ve
  • Expense dates are stored as UTC strings in RFC3339 format, however, the frontend hides the time value from the user; users are meant to select a date, and the current local time is automatically added to the given date
  • Future and recurring expenses extending into future dates are added immediately to the backend
  • The primary way to use ExpenseOwl is to quick review the month's stats via the pie chart - this allows users to make a mental note and soft decision of where to spend money, without the effort of maintaining a budget
  • Categories are meant to be used as a classification criteria - example, how much did I spend on food, groceries, and utilities, etc.
  • Tags are optional and are meant to assign features and characteristics to expenses.

[!NOTE] While these conventions can change during the project's lifecycle, largely, the intention (stemming from the motivation to build ExpenseOwl) behind simple, manual, easy tracking will not change.

Configuration Options

With the exception of Data backends, all configuration of ExpenseOwl happens via the application UI. The list of all such options available via the settings page (/settings endpoint) is as follows:

  • Category Settings:
  • Currency Symbol:
    • This is a frontend symbol configuration on what symbol to use to show amount values
    • Each currency has its default behavior for using , or . as separators (and if it uses decimals or not)
  • Start Date:
    • This is a custom day of the month from when the expenses will be displayed
    • Example: setting it to 5 means, expenses for each month will be counted from 5th to next month's 4th
  • Recurring Transactions:
    • A recurring transaction can be for an expense or an income (gain)
    • Given a value for number of occurences and a start date, the app will add the transactions accordingly
    • Recurring transactions will be listed at the bottom of the page and can be edited/removed (all or future only transactions)
    • Recurring transactions allow similar options as normal expenses - category, tags, amount, name
  • Theme Settings: supports light an

readme truncated — read the full docs on github

Frequently asked questions

Is ExpenseOwl free to use?

ExpenseOwl is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does ExpenseOwl do?

Extremely simple, self-hosted expense tracker with a beautiful UI.

What is ExpenseOwl written in?

ExpenseOwl is primarily written in HTML. Its source is publicly available at https://github.com/Tanq16/ExpenseOwl, and it has 1,510 GitHub stars.