Self-Hosted Personal Finance: n8n + Actual Budget + Claude

Self-hosting personal finance automation means running the budgeting app, the bank-sync bridge, and the automation layer on hardware under one's own control, rather than trusting an ongoing subscription service with account credentials and transaction history. A stack built from Actual Budget, SimpleFIN, n8n, and the Claude API covers budgeting, bank sync, and AI-assisted categorization without a monthly SaaS fee for the budgeting layer itself.

Why self-host personal finance automation

Commercial budgeting apps require linking bank credentials to a third-party server that retains transaction history indefinitely, and many popular apps have shifted to subscription pricing. A self-hosted stack changes the trust model: transaction data lives in a database the user controls, and the only recurring external dependency is the bank-linking bridge (SimpleFIN) and, optionally, calls to an AI API for categorization or summarization.

This isn't a zero-cost or zero-trust proposition — SimpleFIN's bridge and Anthropic's API are still third parties in the loop — but it removes the budgeting app itself as a party with standing access to full financial history, and it avoids an ongoing subscription for the core app.

The pattern of running useful software on a small, dedicated, always-on box mirrors other homelab projects, from self-hosting Jellyfin on a Raspberry Pi 4 to running a self-hosted AI stack on the same hardware class. Personal finance automation fits the same low-power, always-on profile.

The stack, piece by piece

Actual Budget has a built-in SimpleFIN integration, so linked accounts can sync transactions without manual CSV exports. n8n sits alongside it as the orchestration layer — running scheduled jobs, calling Actual Budget's API, and optionally routing transaction text to Claude for a category suggestion or a plain-language summary.

Step-by-step setup

1. Deploy Actual Budget with Docker

Actual Budget's official documentation covers a Docker Compose deployment for both the desktop-style app and its optional sync server, which is what makes multi-device and automated access possible. Running it behind the homelab's existing reverse proxy (if one exists) keeps the budgeting UI reachable without exposing the container directly to the internet. The official Docker install guide is the source to follow step-by-step rather than a third-party summary, since the exact Compose file changes between releases.

2. Connect accounts through SimpleFIN

SimpleFIN acts as the bridge between a bank or card account and any budgeting app that supports it — Actual Budget is one of the apps with native support. Setup happens through SimpleFIN's own account-linking flow rather than storing bank passwords directly in Actual Budget, which keeps credential handling out of the self-hosted app's threat surface. Once linked, Actual Budget pulls transactions from the SimpleFIN bridge instead of requiring a manual import.

3. Automate categorization and routing with n8n

With n8n deployed (also via Docker, per n8n's own documentation), a workflow can be built around a simple loop:

1. A scheduled trigger runs on an interval (hourly or daily is typical for a personal finance loop).
2. An HTTP Request node pulls newly-synced, uncategorized transactions from Actual Budget's API.
3. Each transaction description is sent to Claude via the Anthropic API for a suggested category or a flag if it looks anomalous relative to recent spending.
4. The result is written back into Actual Budget, or, for anything Claude flags as unusual, a notification is routed to email or a chat webhook.

n8n's node-based builder and its published integrations directory make steps 2–4 achievable without custom backend code — the automation is assembled from existing HTTP Request and webhook nodes rather than a standalone script.

4. Use Claude for insight generation, not just tagging

Beyond per-transaction categorization, the same n8n-to-Claude pattern can generate a weekly plain-language summary: total spend by category, month-over-month deltas pulled from Actual Budget's own reporting, and flagged outliers. Because this step calls the Claude API rather than running a model locally, the accuracy and latency depend on Anthropic's hosted models — per Anthropic's API documentation — not on local hardware.

This is a meaningfully different architecture from running a local LLM for private inference, which is the pattern covered in SpecPicks' look at local RAG versus frontier models on financial data. That piece is relevant context here specifically because it's about the tradeoff this stack is choosing not to make: sending transaction text to a cloud API is a smaller privacy compromise than sending it to a general-purpose cloud budgeting SaaS, but it is not the same as fully local inference. Anyone who wants zero data leaving the homelab for the AI step would need to swap Claude for a locally-hosted model, which reintroduces the GPU and RAM requirements a pure API integration avoids.

Hardware requirements for the finance homelab node

A common misconception in homelab writeups is that any AI-adjacent project needs a GPU. That's true for local model inference — see SpecPicks' Raspberry Pi self-hosted AI home lab piece for what's realistic on small hardware when the model runs locally — but it's not true here, because Claude runs remotely via API call. The homelab box only needs to run three lightweight Docker containers (Actual Budget, its sync server, and n8n) and make outbound HTTPS requests.

In practice, a Raspberry Pi 4 or 5, a low-power mini PC, or a spare partition on an existing NAS is enough to run this whole stack continuously. Desktop-class multi-core CPUs are unnecessary for this particular combination of services — that hardware class matters for local LLM inference or transcoding workloads, not for orchestrating API calls and a small budgeting database.

Keeping the homelab node tidy and reliable

An always-on box tucked next to a router or under a desk still needs basic physical housekeeping so cables don't come loose and the box doesn't get knocked around. A few low-cost additions cover this: self-adhesive cable organizers keep Ethernet and power runs off the floor, cable clips route individual cables along a desk edge, assorted zip ties bundle the inevitable tangle behind a small switch or router, and non-slip furniture pads under a mini PC or Pi case reduce vibration noise and prevent it from sliding on a shelf. None of this is exotic — it's the same cable-management approach that applies to any small always-on appliance.

Common setup issues

Docker containers can't reach each other. If n8n's HTTP Request node can't reach Actual Budget's API, the containers are usually on different Docker networks or the request is using localhost instead of the container's service name. Placing both containers in the same Docker Compose network and referencing the service name (not localhost) in n8n's request URL resolves most of these failures.

SimpleFIN sync stalls. A stalled sync is most often a re-authentication issue on the bridge side rather than an Actual Budget problem — SimpleFIN's own status and re-link flow is the first place to check before troubleshooting the budgeting app.

Claude API calls fail or time out in n8n. This is typically an authentication or rate-limit issue rather than a network problem — confirming the API key and request format against Anthropic's current API documentation resolves most of these before they need deeper debugging.

Workflow runs pile up. For a personal-finance use case, an hourly or daily trigger is plenty — running the categorization workflow on every webhook event rather than a schedule can needlessly multiply API calls for no practical benefit at personal-finance transaction volumes.

Is this worth it compared to a commercial budgeting app?

The tradeoff is setup time versus ongoing cost and data control. A commercial app is faster to start with and requires no Docker knowledge; a self-hosted stack takes an afternoon to assemble but removes recurring subscription costs for the budgeting layer and keeps transaction history off a third-party server long-term, with the AI step being the one component that still leaves the homelab per request. For anyone already running homelab services — the same instinct behind self-hosting Jellyfin or running Open WebUI as a self-hosted LLM front-end — adding a lightweight finance stack is a small incremental addition rather than a new infrastructure project.

Citations and sources

• Actual Budget — official site
• Actual Budget — Docker installation docs
• Actual Budget — GitHub repository
• SimpleFIN — official site
• n8n — official site
• n8n — documentation
• Anthropic — API product page

This piece is editorial synthesis based on publicly available information. No independent first-party benchmarking is reported.