# Betreibe dein eigenes Beancount.io mit einem Klick

Deploye den gesamten Beancount.io-Stack – die Web-App, die API, den MCP-Server und deine Git-gestützten Ledger – in etwa 30 Minuten in deinen eigenen bex-Workspace. Null Konfiguration, keine Plan-Limits, MIT-lizenziert und rund 33 $/Monat für das Hosting.



Beancount gibt dir die volle Kontrolle über deine Finanzen in Klartext. Die Software rund um diese `.bean`-Dateien selbst zu besitzen, war bisher schwieriger: Eine Web-Oberfläche, CLI und einen KI-Agenten-Endpunkt auf dein Ledger zu setzen, bedeutete entweder, unserem gehosteten Dienst deine Bücher anzuvertrauen, oder sechs Dienste von Hand zu verdrahten.

Ab heute kannst du deine eigene private Beancount.io-Instanz mit einem einzigen Klick hochfahren.

Klicke auf **Deploy to bex.co**, wähle den Workspace, dem der Stack gehören soll, und bestätige den Plan. Es gibt nichts zu konfigurieren – jedes Secret wird automatisch innerhalb deines Workspace erzeugt. Etwa 30 Minuten später ist dein Dashboard live. Erstelle dein Konto, und die Registrierung schließt sich hinter dir; niemand sonst kommt hinein, es sei denn, du lädst ihn über deinen eigenen Identity Provider ein.

[![Deploy to bex.co](/img/blog/run-your-own-beancount-io-from-one-button/deploy-to-bex.svg)](https://dashboard.bex.co/deploy?repo=https://github.com/bex-co/beancount-io&path=bex.yaml)

Dein Ledger lebt als Standard-Git-Repository auf einer Festplatte in deinem Workspace. Jede Oberfläche zeigt strikt auf deine Adresse, nicht auf unsere: das Web-Dashboard, die `bea`-CLI, Coding-Agenten über den eingebauten MCP-Server oder einfaches `git` (wo `bea` dich authentifiziert). Es gibt keine Plan-Limits für Ledger, Direktiven oder KI-Nutzung, und der Stack sendet keine Analytics an Beancount.io zurück.

Optionale Integrationen bleiben aus, bis du sie brauchst: Bring deinen eigenen Modellschlüssel für Beleg-Scanning, Kategorisierung und den Assistenten mit; einen S3-Bucket für Beleg-Uploads; oder einen Mail-Schlüssel für Passwort-Resets. Bis du sie hinzufügst, zeigt jede Funktion einfach an, welche Einstellung sie benötigt – alles andere funktioniert von Anfang an.

## Was du bekommst und was es kostet

Das Deployment stellt sechs Dienste bereit, die direkt mit deinem bex-Workspace abgerechnet werden (Preise aus der Plan-Vorschau von bex vom 18.11.2026):

| Dienst | Funktion | Monatliche Kosten (USD) |
| --- | --- | --- |
| Dashboard | Die Web-App und die einzige öffentliche Adresse, die du nutzt | 4,90 $ |
| API | GraphQL, REST, MCP-Server und der Git-Proxy | 4,90 $ |
| Ledger-Service | Validiert und fragt deine Bücher ab (privat, keine öffentliche Adresse) | 4,90 $ |
| Gitea | Speichert jedes Ledger als Git-Repo auf einer 10-GB-Festplatte (privat) | 6,65 $ |
| Postgres | Konten, Tokens und Einstellungen | 4,41 $ |
| Key Value | Anmelde-Sessions und Caches | 7,21 $ |
| **Gesamt** | | **32,97 $** |

Jeder externe Modell-Provider, Mail-Dienst oder S3-Bucket, den du verbindest, wird separat von diesen Anbietern abgerechnet.

> **Bevor du alles abbaust:** Das Löschen der Ressourcen stoppt sofort die Rechnung – **und löscht deine Daten mit.** Klone deine Git-Ledger immer zuerst.

Jedes Konto auf einem selbst gehosteten Stack erhält automatisch die höchste Stufe – keine künstlichen Obergrenzen:

![Einstellungen, Abrechnung auf einem selbst gehosteten Stack: der Enterprise-Plan, mit unbegrenzten KI-Tokens, Ledgern, Direktiven und Mitwirkenden.](/img/blog/run-your-own-beancount-io-from-one-button/no-plan-limits.webp)

## Vom einen Klick bis zum ersten Ledger

1. **Starte den Stack.** Klicke auf **Deploy to bex.co** (oben oder in der [README](https://github.com/bex-co/beancount-io#self-host)), wähle deinen Workspace, prüfe den Plan und bestätige. Nichts wird bereitgestellt, bevor du zustimmst.
2. **Warte auf den ersten Build.** Der erste Build dauert in unseren Läufen 27–30 Minuten (länger, wenn die Build-Queue von bex ausgelastet ist). Wenn ein Dienst einen fehlgeschlagenen Rollout anzeigt, löse im bex-Dashboard ein erneutes Deployment aus.
3. **Übernimm deine Instanz.** Öffne deine Dashboard-URL und registriere dich sofort – es gibt keinen E-Mail-Verifizierungsschritt.
4. **Erstelle ein Ledger.** Beginne neu mit der Starter-Vorlage oder lade das Beispiel-Ledger, um dich umzusehen.

> **Sicherheitshinweis:** Bis das erste Konto erstellt ist, kann jeder, der deine URL entdeckt, sie übernehmen. Falls dir jemand zuvorkommt, kannst du [dieses Konto entfernen](https://github.com/bex-co/beancount-io/blob/main/docs/prfaqs/PRFAQ006-self-host-on-bex.md#13-someone-signed-up-before-me-what-now) und mit dem Admin-Token des Stacks die Registrierung wieder öffnen.

![Registrierung auf einem neuen selbst gehosteten Deployment. Neben dem Formular steht auf der Seite, dass diese Kopie vom Eigentümer betrieben wird und die Bücher als Klartext in Git liegen.](/img/blog/run-your-own-beancount-io-from-one-button/sign-up.webp)

## Richte deine Tools auf deine eigene Adresse aus

### Die `bea`-CLI

Installiere oder aktualisiere [`bea`](/docs/Basics/bea-cli) über `uv tool install beancount-io` oder `brew install bex-co/tap/bea` und richte es dann auf dein Dashboard aus:

```zsh
export BEA_API_URL=https://<deine Dashboard-Adresse>
export BEA_DASHBOARD_URL=https://<deine Dashboard-Adresse>
bea cloud login            # meldet dich über deinen Browser an
bea cloud ledger list
```

Beide Umgebungsvariablen verwenden dieselbe Dashboard-URL, die für dich den API-Datenverkehr weiterleitet.

![bea 0.4.1 gegen ein selbst gehostetes Deployment: bea cloud login, bea cloud status im Enterprise-Plan und bea cloud ledger list.](/img/blog/run-your-own-beancount-io-from-one-button/bea-login.webp)

### Coding-Agenten (MCP)

Verbinde Claude Code oder einen beliebigen MCP-kompatiblen Client direkt mit deinem Deployment:

```zsh
claude mcp add --transport http beancount \
  https://<deine Dashboard-Adresse>/api-gateway/mcp
```

Melde dich über `/mcp` in Claude Code an – der OAuth-Consent-Screen wird von deiner eigenen Instanz bereitgestellt. Für Clients, die stattdessen über Header authentifizieren, erzeuge unter **Einstellungen → Personal Access Tokens** einen Token und übergib ihn als `Authorization: Bearer <token>`. Auf unserem Test-Stack hat ein MCP-Client sofort 47 Tools bereitgestellt und BQL-Abfragen direkt gegen das Ledger ausgeführt.

![Ein MCP-Client, der mit einem Personal Access Token auf die eigene Adresse des Deployments zeigt: 47 Tools und eine BQL-Abfrage über das Ledger.](/img/blog/run-your-own-beancount-io-from-one-button/mcp-client.webp)

### Einfaches Git

Jedes Ledger ist ein Git-Repository unter `https://<deine API-Adresse>/git/<owner>/<ledger>.git` (die exakte URL kannst du dem Menü **Git Clone** des Ledgers entnehmen). Da bex kein SSH routet, läuft Git über HTTPS – und `bea` übernimmt die Zugangsdaten für dich:

```zsh
bea cloud login            # einmalig, falls noch nicht geschehen
bea cloud git setup        # konfiguriert Git, um sich mit deiner bea-Session zu authentifizieren
git clone https://<deine API-Adresse>/git/<owner>/<ledger>.git
```

Von dort an funktionieren `git clone`, `git pull` und `git push` auf diesem Host ohne Nachfrage, und `bea cloud logout` löscht auch die Git-Zugangsdaten. *(Hinweis: `bea cloud ledger clone` klont nicht direkt über HTTPS; auf Servern ohne SSH gibt es diese Befehle für dich aus.)*

![Das Git-Clone-Menü eines Ledgers: die HTTPS-Adresse der API, mit einem Personal Access Token als Passwort.](/img/blog/run-your-own-beancount-io-from-one-button/git-clone-menu.webp)

#### Git ohne `bea` nutzen (CI-Runner & Skripte)

Wenn du `bea` lieber nicht auf einem Rechner oder CI-Runner installieren möchtest, authentifiziere dich mit einem Personal Access Token – ganz wie bei GitHub:

1. **Erstelle einen Token.** Gehe zu **Einstellungen → Personal Access Tokens → Neuer Token**. Benenne ihn nach seiner Umgebung (`laptop`, `nightly-backup`), wähle `ledger.read` zum Klonen/Pullen und füge `ledger.write` hinzu, wenn gepusht werden muss. Beschränke ihn für unbeaufsichtigte Skripte auf ein einzelnes Ledger und setze ein Ablaufdatum. Kopiere den `bcio_...`-Token sofort – er wird nur einmal angezeigt.

   ![Einstellungen, Personal Access Tokens: ein Token mit ledger.read und ledger.write, seinem Präfix und wann er erstellt und zuletzt verwendet wurde.](/img/blog/run-your-own-beancount-io-from-one-button/access-tokens.webp)

2. **Klonen und zwischenspeichern.** Gib beim ersten Klonen eine beliebige nicht-leere Zeichenkette als Benutzername und den Token als Passwort ein. macOS (Keychain) und Windows (Git Credential Manager) speichern ihn automatisch. Aktiviere unter Linux zuerst einen Credential Helper: `git config --global credential.helper store` (Klartext in `~/.git-credentials`) oder `credential.helper 'cache --timeout=86400'` (24 Stunden im Speicher).

Für Skripte und geplante Backups halte den Token aus der Remote-URL heraus (damit er nicht in `.git/config` geschrieben wird) und aus deiner Shell-Historie, indem du einen einmaligen Credential Helper übergibst:

```zsh
read -rs BEANCOUNT_TOKEN; export BEANCOUNT_TOKEN
helper='!f() { echo username=token; echo "password=$BEANCOUNT_TOKEN"; }; f'
git -c credential.helper= -c credential.helper="$helper" \
  clone --mirror https://<deine API-Adresse>/git/<owner>/<ledger>.git
```

Das leere `-c credential.helper=` verhindert, dass dein lokaler Keychain oder `~/.git-credentials` den Token zwischenspeichert. Übergib beide `-c`-Flags an jedes weitere `git fetch` oder `git push` in deinem Skript.

> **Fehlerbehebung bei Zugangsdaten:** Wenn Git wiederholt ein altes Passwort oder einen widerrufenen Token probiert, lösche ihn mit `printf 'protocol=https\nhost=<deine API-Adresse>\n\n' | git credential reject`. Passwortbasierte Git-Authentifizierung funktioniert vorerst noch, wird aber schrittweise abgeschafft.

**Bestehende Bücher migrieren?** Erstelle ein neues Ledger, führe deine Dateien oder deine Git-Historie darin zusammen und pushe sie. Der Stack liest `main.bean` als Einstiegspunkt, also benenne deine Root-Datei entweder `main.bean` oder verwende sie, um deine bestehenden Dateien per `include` einzubinden.

## Was deinen Workspace verlässt

Der Stack sendet keine Analytics oder Telemetrie an Beancount.io, und das Browser-Analytics-Skript wird vollständig aus dem Build entfernt. Die einzigen uns bekannten ausgehenden Anfragen sind:

- **Passwort-Leak-Prüfungen:** Die ersten 5 Zeichen des SHA-1-Hashes eines neuen Passworts werden über k-Anonymität geprüft (weder dein Passwort noch dein Konto wird offengelegt).
- **Avatare:** Browser-Anfragen an Gravatar unter Verwendung eines Hashes der E-Mail-Adresse des Nutzers.
- **Feeds:** Anfragen für die Blog- und Changelog-Feeds von Beancount.io (sendet nur eine Sprachpräferenz, keine Nutzerdaten).
- **Preis-Feeds:** Anfragen an beancount.io *nur*, wenn dein Ledger ausdrücklich eine verwaltete Preis-URL enthält.
- **Deine eigenen Integrationen:** Daten, die an Dienste gesendet werden, für die du dich entscheidest (LLM-Anbieter, SendGrid, S3, Plaid oder dein OIDC-Provider).

Sieh dir die [vollständige Datenschutz-Tabelle](https://github.com/bex-co/beancount-io/blob/main/docs/prfaqs/PRFAQ006-self-host-on-bex.md#12-is-my-data-private) an, um genaue Details dazu zu erhalten, wann jede Anfrage ausgelöst wird.

## Wer die Maschinen betreibt

Deine Dienste, Festplatte und Datenbank laufen auf bexs Infrastruktur, in deinem Workspace und auf deiner Rechnung. Volle Transparenz: bex wird von Stargately, Inc. gebaut – demselben Unternehmen hinter Beancount.io – und das Hosting unterliegt bexs [Datenschutzrichtlinie](https://bex.co/privacy-policy) und [Nutzungsbedingungen](https://bex.co/terms-of-service). Der gehostete Beancount.io-Dienst ist vollständig getrennt von deinem Stack und enthält keine seiner Secrets.

Bevorzugst du es, auf Hardware zu laufen, die du direkt kontrollierst? Unser [Docker-Deployment](https://github.com/bex-co/beancount-io/tree/main/deploy/docker) betreibt genau denselben Stack auf jedem Server, den du besitzt.

## Gut zu wissen

- **Standardmäßig Einzelnutzer, OIDC für Teams oder Familie.** Die Registrierung schließt nach dem ersten Konto. Um weitere hinzuzufügen, verbinde einen OpenID-Connect-Provider und liste die erlaubten Adressen in `OIDC_ALLOWED_EMAILS` auf ([Einrichtungsanleitung](https://github.com/bex-co/beancount-io/tree/main/deploy/bex#more-accounts-your-own-identity-provider)). 2FA wird von deinem Identity Provider verwaltet.
- **Updates nach deinem Zeitplan.** Dein Stack bleibt auf der Version, die du deployt hast, bis du dich entscheidest, das Blueprint zu synchronisieren und neu zu deployen ([Anleitung zum Aktualisieren](https://github.com/bex-co/beancount-io/tree/main/deploy/bex#rolling-out-a-change)).
- **Unkomplizierte Backups.** Ledger sind einfach Git-Repos – `git clone --mirror` sichert deine gesamte Historie. Konten, Tokens und Einstellungen liegen in einem verwalteten Postgres mit kontinuierlichen Backups und Point-in-Time-Recovery ([Backup-Anleitung](https://github.com/bex-co/beancount-io/tree/main/deploy/bex#back-up-and-restore)).
- **Unterstützung für die Mobile-App.** Öffne im Begrüßungsbildschirm der Mobile-App die Einstellungen, richte die Server-URL auf deine Dashboard-Adresse und melde dich an.

Alle Schritte an einem Ort, einschließlich Updates, Backups, Passwort-Resets und dem Entfernen des Stacks, findest du in der [Self-Hosting-Anleitung](/docs/self-host-beancount-io).

Auf ein Problem gestoßen? Öffne ein [GitHub-Issue](https://github.com/bex-co/beancount-io/issues) oder komm in den [Telegram-Chat](https://t.me/beancount).
