Journaalposten vormen de ruggengraat van dubbele boekhouding, en in Beancount is elke * transactie die je schrijft een journaalpost. Deze gids legt de essentie uit — debet en credit, correctieposten en omkeerposten — en laat zien hoe ze netjes overeenkomen met de platte‑tekst syntaxis van Beancount. Je leert hoe je nauwkeurige boeken bijhoudt met minimale ceremonie.

Een snelle opfrisser: wat is een journaalpost?​

Een journaalpost is de formele, gedateerde registratie van een financiële transactie. Hij wordt uitgedrukt in termen van debet en credit die de fundamentele boekhoudkundige vergelijking in balans houden:

$Activa = Passiva + Eigen vermogen$

In een dubbel‑postingssysteem beïnvloedt elke transactie minstens twee rekeningen, en het totaal van debet moet gelijk zijn aan het totaal van credit. Deze eenvoudige regel maakt downstream‑rapporten zoals de winst‑en‑verliesrekening en de balans betrouwbaar en accuraat.

Debet en credit in één minuut​

De concepten debet en credit kunnen in het begin verwarrend zijn, maar ze komen neer op een paar eenvoudige regels. Denk eraan: “waar kwam de waarde vandaan?” (credit) en “waar ging de waarde naartoe?” (debet).

Hier is een cheat‑sheet voor hoe ze de vijf kernrekeningtypen verhogen:

Hoe een journaalpost eruitziet in Beancount​

Beancount gebruikt eenvoudige, menselijk leesbare tekst‑directieven om transacties vast te leggen. Elke transactie moet voor elke commodity (bijv. USD, EUR, AAPL‑aandelen) op nul balanceren. Beancount geeft een foutmelding als dat niet het geval is.

Hier is een basis‑transactie voor het kopen van koffie:

2025-09-10 * "Coffee Bar" "Team coffee"
  Expenses:Food:Coffee          18.00 USD
  Assets:Bank:Checking         -18.00 USD

Let op hoe de twee boekingen (regels met rekeningen) optellen tot nul: $18.00 + (-$18.00) = 0.

Je kunt krachtige context direct in de narratie opnemen met tags (bijv. #clientX) voor filteren en links (bijv. ^INV-2025-001) om gerelateerde posten te verbinden.

Bijvoorbeeld, zo kun je een factuur koppelen aan de betaling:

; Eerst, registreer de factuur die je naar de klant hebt gestuurd
2025-09-15 * "Acme Corp" "Invoice 2025-001 #clientX ^INV-2025-001"
  Assets:AccountsReceivable   1000.00 USD
  Income:Consulting         -1000.00 USD

; Later, registreer de betaling en koppel deze terug aan de oorspronkelijke factuur
2025-09-28 * "Acme Corp" "Payment on ^INV-2025-001"
  Assets:Bank:Checking       1000.00 USD
  Assets:AccountsReceivable -1000.00 USD

De #clientX‑tag laat je gemakkelijk alle transacties voor deze klant filteren, en de ^INV-2025-001‑link creëert een verbinding tussen de twee posten die je in rapporten kunt volgen.

Veelvoorkomende journaalposten (klaar om te plakken)​

Hieronder staan verschillende gangbare zakelijke transacties geformatteerd voor Beancount.

Eigenaar brengt contant geld in​

Een eigenaar draagt persoonlijke middelen bij om het bedrijf te starten.

2025-01-01 * "Owner" "Initial capital contribution"
  Assets:Bank:Checking        10000.00 USD
  Equity:Owner-Capital      -10000.00 USD

Contante verkoop met omzetbelasting​

Een klant betaalt contant voor een product, inclusief 8 % omzetbelasting die je later aan de overheid moet afdragen.

2025-01-05 * "Walk-in Customer" "Cash sale with 8% tax"
  Assets:Cash                   108.00 USD
  Income:Sales                -100.00 USD
  Liabilities:Tax:Sales         -8.00 USD

Verkoop op rekening (factuur) en incasso​

Je levert een dienst en factureert de klant, waarna je later de betaling ontvangt.

2025-01-10 * "Acme Corp" "Consulting invoice ^INV-2025-002"
  Assets:AccountsReceivable   2500.00 USD
  Income:Consulting         -2500.00 USD

2025-01-30 * "Acme Corp" "Payment on ^INV-2025-002"
  Assets:Bank:Checking       2500.00 USD
  Assets:AccountsReceivable -2500.00 USD

Kosten op creditcard​

Je koopt kantoorbenodigdheden met een bedrijfscreditcard.

2025-01-12 * "OfficeMax" "Supplies on credit card"
  Expenses:Office:Supplies       75.00 USD
  Liabilities:CreditCard        -75.00 USD

Loonadministratie (eenvoudig model)​

Je verwerkt de loonlijst, registreert de brutoloonkosten, de door de werknemer ingehouden belastingen, en de netto‑betaling van je bank.

2025-01-31 * "Payroll" "January wages and withholdings"
  Expenses:Payroll:Wages      2000.00 USD
  Liabilities:Taxes:Withheld   -400.00 USD
  Assets:Bank:Checking       -1600.00 USD

Maandelijkse afschrijving​

Je boekt de maandelijkse afschrijvingskosten voor een activum, zoals een laptop.

2025-01-31 * "Depreciation" "Laptop, straight-line"
  Expenses:Depreciation          100.00 USD
  Assets:Equipment:AccumDepr    -100.00 USD

Vooruitbetaalde kosten & maandelijkse amortisatie​

Je betaalt een heel jaar verzekering vooruit, en erkent vervolgens één maand van de kosten.

; 1. Betaling van de jaarlijkse polis
2025-01-01 * "InsureCo" "Annual insurance premium"
  Assets:Prepaid:Insurance     1200.00 USD
  Assets:Bank:Checking       -1200.00 USD

; 2. Erken één maand kosten aan het einde van januari
2025-01-31 * "InsureCo" "Amortize 1/12 of insurance"
  Expenses:Insurance             100.00 USD
  Assets:Prepaid:Insurance      -100.00 USD

Nog te ontvangen omzet & maandelijkse erkenning​

Een klant betaalt vooraf voor een abonnement van 3 maanden. Je registreert het geld en erkent daarna één maand omzet.

; 1. Klant betaalt vooraf voor de dienst
2025-02-01 * "Subscriber" "3-month plan prepaid"
  Assets:Bank:Checking           300.00 USD
  Liabilities:Unearned:Subs     -300.00 USD

; 2. Erken één maand omzet na levering van de dienst
2025-02-28 * "Recognition" "Recognize month 1 of 3"
  Liabilities:Unearned:Subs      100.00 USD
  Income:Subscriptions          -100.00 USD

Oninbare vorderingen & afschrijving​

Je reserveert een voorziening voor mogelijk oninbare facturen en schrijft later een specifieke slechte vordering af.

; 1. Voorziening aanmaken op basis van 2 % van debiteuren
2025-03-31 * "Provision" "2% of A/R for doubtful accounts"
  Expenses:BadDebt               200.00 USD
  Assets:AllowanceForDoubtful   -200.00 USD

; 2. Specifieke factuur afschrijven die niet betaald zal worden
2025-04-15 * "Write-off" "Customer XYZ invoice"
  Assets:AllowanceForDoubtful    150.00 USD
  Assets:AccountsReceivable     -150.00 USD

Periodieke voorraad & COGS‑aanpassing​

Aan het einde van een periode bereken je de kostprijs van verkochte goederen (COGS) door je voorraadrekening aan te passen.

2025-03-31 * "COGS adjustment" "Periodic inventory method"
  Expenses:COGS                4500.00 USD
  Assets:Inventory           -4500.00 USD

Correctieposten vs. omkeerposten​

Correctieposten worden aan het einde van een boekhoudperiode (bijv. een maand of kwartaal) vastgelegd om opbrengsten en kosten correct toe te wijzen aan de periode waarin ze daadwerkelijk zijn verdiend of gemaakt. Dit omvat accruals, deferrals en schattingen zoals afschrijvingen.

Omkeerposten zijn optionele boekingen die op de eerste dag van een nieuwe periode exact de vorige correctiepost terugdraaien. Het doel is de boekhouding te vereenvoudigen. Door een accrual om te keren, kun je de daaropvolgende kastransactie op een standaard manier boeken zonder te hoeven onthouden dat je tegen de passivarekening moet boeken.

Voorbeeld: accrual en omkering van nutsvoorzieningen​

Stel, je moet de nutskosten van januari boeken, maar de factuur komt pas in februari.

; 1. Accrue de geschatte kosten aan het einde van januari
2025-01-31 * "Accrual" "Estimate January utilities expense"
  Expenses:Utilities              500.00 USD
  Liabilities:Accrued:Utilities  -500.00 USD

; 2. (Optioneel) Keer de accrual om op de eerste dag van de volgende periode
2025-02-01 * "Reversal" "Undo January utilities accrual"
  Liabilities:Accrued:Utilities   500.00 USD
  Expenses:Utilities             -500.00 USD

; 3. Boek de daadwerkelijke factuurbetaling wanneer deze in februari binnenkomt
; De werkelijke factuur bedraagt $520. Door de omkering kun je
; het volledige bedrag naar de kostenrekening boeken zonder problemen.
; De netto‑kosten voor feb zijn $520 - $500 = $20.
2025-02-10 * "City Utilities" "Payment for January bill"
  Expenses:Utilities             520.00 USD
  Assets:Bank:Checking          -520.00 USD

Opmerking: Het voorbeeld in de outline laat zien hoe de uiteindelijke betaling wordt opgesplitst. De omkeerpost‑methode is een alternatief dat de uiteindelijke betaling vereenvoudigt.

Checklist voor elke Beancount‑journaalpost​

Volg deze stappen om te zorgen dat je posten schoon en correct zijn:

1. Begin met de datum (JJJJ‑MM‑DD) en een transactie‑vlag (*).
2. Voeg een begunstigde en een beschrijvende narratie toe. Gebruik #tags en ^links voor doorzoekbaarheid.
3. Neem minimaal twee boekingsregels op die voor elke commodity op nul balanceren.
4. Gebruik juiste rekeningsnamen onder de vijf typen: Assets, Liabilities, Equity, Income, Expenses.
5. Optioneel, voeg metadata toe zoals document: "invoices/INV-2025-001.pdf" voor traceerbaarheid.

Veelvoorkomende valkuilen (en hoe Beancount helpt)​

• Ongebalanceerde boekingen: Als je debet en credit niet op nul uitkomen, zal Beancount de post weigeren. Dit is een kernfunctie die fouten voorkomt. Je kunt één bedrag zelfs leeg laten, en Beancount berekent het automatisch.
• Verkeerd teken bij een rekening: Het is makkelijk te vergeten dat Income, Equity en Liabilities toenemen met credits (meestal negatieve getallen in Beancount). Als je het fout doet, zien je rapporten er vreemd uit, maar de balanceringsregel biedt nog steeds een vangnet.
• Ontbrekende links tussen posten: Het vergeten om een factuur te koppelen aan de betaling maakt het lastiger om uitstaande bedragen te volgen. Consistent gebruik van ^links lost dit op door een controleerbaar spoor te creëren.

Waar ga je daarna heen​

• Beancount‑taal & balanceringsregels: Duik dieper in de officiële documentatie.
• Syntax‑cheatsheet: Een handige referentie voor alle Beancount‑directieven.
• Debet/Credit‑primer: Een uitstekend startpunt als je nieuw bent met boekhoudregels.
• Correctie‑/omkeerposten: Meer gedetailleerde artikelen over de boekhoudkundige theorie.

Bijlage: Accounting Talk → Beancount‑map​

Deze snelle vertaalgids helpt je om boekhoudkundige instructies naar Beancount‑syntaxis te vertalen.

Met deze patronen en voorbeelden kun je vrijwel elk zakelijk evenement in Beancount modelleren, zodat je financiële rapporten zonder verrassingen kloppen.

Belastingen kunnen aanvoelen als een speciaal, ingewikkeld beest in de wereld van persoonlijke financiën. Maar wat als dat niet zo was? Wat als je ze net als elke andere geldstroom in je grootboek kunt behandelen? Goed nieuws: dat kan. Door belastingen te zien als eenvoudige waardeverplaatsingen blijft je Beancount‑grootboek schoon, gemakkelijk te bevragen en – vooral – begrijpelijk.

Hieronder vind je een praktisch, no‑nonsense patroon dat je in een persoonlijk of klein‑zakelijk Beancount‑bestand kunt opnemen. Het is een simpel systeem voor het verwerken van salarissen, belastingbetalingen en zelfs die vervelende terugbetalingen die over het nieuwe jaar heen gaan. We behandelen de essentiële rekeningen die je nodig hebt, lopen door real‑world voorbeelden, en laten je de exacte queries zien die je moet draaien om de antwoorden te krijgen die je zoekt.

De kernprincipes​

Voordat we in de code duiken, laten we een paar eenvoudige regels afspreken. Deze principes houden alles logisch en voorkomen toekomstige hoofdpijn.

• Scheid “wat het is” van “wanneer het geld beweegt.” 🗓️
  Dit is het belangrijkste concept. Een belastingkost behoort tot het jaar waarin je de inkomsten hebt verdiend (bijv. 2024), zelfs als je de rekening bij de Belastingdienst in april 2025 betaalt. Als je de timing van de kost niet scheidt van de timing van de cash‑betaling, worden je jaar‑over‑jaar rapporten rommelig en misleidend.

• Houd je rekeningshiërarchie saai en simpel. 📁
  Geef je rekeningen duidelijke namen op basis van het type belasting (bijv. IncomeTax, SocialSecurity). Dit maakt je queries ongelooflijk eenvoudig. Rommel geen rekeningnamen met leveranciersnamen of formuliernummers zoals “W‑2” of “1099”; gebruik metadata en tags voor die details.

• Omarm accrual voor einde‑jaar aanpassingen. ⚖️
  Zelfs voor een persoonlijk grootboek is een eenvoudige accrual‑boeking aan het einde van het jaar de schoonste manier om je rapporten accuraat te maken. Het betekent dat je een kost of terugbetaling in het juiste jaar erkent, zelfs als het geld pas later beweegt. Het is één kleine extra stap die je later mentale gymnastiek bespaart.

• Schrijf voor je toekomstige zelf. 🧠
  Je doel is duidelijkheid. Voeg alleen extra details toe, zoals het belastingjaar, aan een rekeningnaam als dat echt je queries makkelijker maakt. Vermijd het creëren van een nieuwe set rekeningen elk jaar (Expenses:Taxes:2024:Federal, Expenses:Taxes:2025:Federal, enz.) tenzij je een dwingende reden hebt. Een platte structuur is vaak makkelijker te beheren.

Een minimale rekeningsstructuur​

Hier is een basisset rekeningen om je op weg te helpen. Deze structuur is gericht op de VS, maar je kunt de namen eenvoudig aanpassen aan het belastingstelsel van je eigen land. Voeg deze open‑directieven gewoon toe aan je Beancount‑bestand.

; --- US Federal Income & Payroll Taxes ---
; Voor geld dat van je salaris wordt ingehouden
2024-01-01 open Expenses:Taxes:Federal:IncomeTax:Withheld       USD
; Voor geschatte betalingen of belasting‑dag rekeningen die je direct betaalt
2024-01-01 open Expenses:Taxes:Federal:IncomeTax:Payments       USD
; Voor belasting‑terugbetalingen die je ontvangt
2024-01-01 open Expenses:Taxes:Federal:IncomeTax:Refunds        USD

; Je FICA‑bijdragen
2024-01-01 open Expenses:Taxes:Federal:SocialSecurity           USD
2024-01-01 open Expenses:Taxes:Federal:Medicare                 USD

; --- Andere veelvoorkomende belastingen ---
; Voor omzet‑/gebruikstaks die je betaalt bij aankopen
2024-01-01 open Expenses:Taxes:Sales                            USD

; --- Rekeningen voor einde‑jaar aanpassingen (optioneel maar aanbevolen!) ---
; Een tijdelijke holding‑rekening voor belastingen die je verschuldigd bent maar nog niet hebt betaald
2024-01-01 open Liabilities:AccruedTaxes:Federal:Income         USD
; Een tijdelijke holding‑rekening voor een terugbetaling die je nog moet ontvangen
2024-01-01 open Assets:Tax:Receivable                           USD

Deze opzet scheidt ingehouden belastingen van directe betalingen en terugbetalingen, waardoor je in één oogopslag ziet waar je geld naartoe is gegaan. De Liabilities‑ en Assets‑rekeningen zijn ons geheime wapen om einde‑jaar rapportage accuraat te houden.

Voorbeeld 1: Het salaris​

Boek een typisch salaris waarbij belastingen automatisch worden ingehouden. De sleutel is eerst je brutosalaris te registreren, daarna laten zien hoe het wordt opgesplitst tussen belastingen en het geld dat daadwerkelijk op je bankrekening terechtkomt.

2025-07-15 * "Employer Inc." "Salary for first half of July"
  Income:Work:Salary                                  -6,000.00 USD
  Expenses:Taxes:Federal:IncomeTax:Withheld             1,200.00 USD
  Expenses:Taxes:Federal:SocialSecurity                   372.00 USD
  Expenses:Taxes:Federal:Medicare                          87.00 USD
  Assets:Cash:Checking                                  4,341.00 USD

Deze enkele transactie vertelt het hele verhaal:

• Je hebt $6.000 bruto verdiend.
• $1.200 daarvan is naar de IRS gestuurd voor federale inkomstenbelasting.
• $372 ging naar Social Security en $87 naar Medicare.
• De resterende $4.341 is wat je netto hebt ontvangen.

Pro‑tip: Je kunt metadata van je loonstrookje (bijv. pay_period_end: "2025-07-15") aan de transactie toevoegen voor een eenvoudig audit‑pad.

Voorbeeld 2: Je aangifte indienen (Het jaar‑overstijgende probleem)​

Hier is het scenario dat mensen vaak in de war brengt: Het is april 2025 en je doet je 2024‑aangifte. Je ontdekt dat je, na al het ingehouden, nog een extra $3.000 moet betalen.

Hoe registreer je dit? Je wilt de kost laten meetellen in 2024, maar de cash‑betaling gebeurt in 2025. Hieronder twee uitstekende manieren.

Optie A: Handmatige twee‑stappen accrual​

Deze methode is pure Beancount, geen plugins nodig. Het is een duidelijke, twee‑stappen aanpak.

Stap 1: Erken de kost aan het einde van het belastingjaar.
Op de laatste dag van 2024 maak je een “true‑up” entry. Er beweegt nog geen cash; je erkent alleen de kost en parkeert deze in een tijdelijke liability‑rekening.

2024-12-31 * "Federal income tax true-up for 2024"
  Expenses:Taxes:Federal:IncomeTax:Payments             3,000.00 USD
  Liabilities:AccruedTaxes:Federal:Income             -3,000.00 USD

Nu toont je resultatenrekening van 2024 deze $3.000 kost correct.

Stap 2: Registreer de cash‑betaling wanneer deze plaatsvindt.
In april 2025, wanneer je het geld daadwerkelijk naar de IRS stuurt, maak je de liability leeg.

2025-04-15 * "IRS" "Payment for 2024 tax return"
  Liabilities:AccruedTaxes:Federal:Income              3,000.00 USD
  Assets:Cash:Checking                                -3,000.00 USD

Je 2024‑rapporten zijn correct, en je cash‑flow van 2025 ook. Perfect! Ditzelfde patroon werkt omgekeerd voor een terugbetaling — gebruik dan Assets:Tax:Receivable in plaats van de liability‑rekening.

Optie B: Automatiseren met een plugin​

Wil je de betaling in één enkele transactie houden, dan kun je de community‑plugin beancount_reds_plugins.effective_date gebruiken. Hiermee kun je een andere “effective date” toekennen aan een regel.

Eerst de plugin inschakelen in je hoofd‑Beancount‑bestand:
plugin "beancount_reds_plugins.effective_date"

Daarna kun je één transactie schrijven; de plugin splitst deze achter de schermen zodat je rapporten accuraat blijven.

; Eén entry; de plugin doet de rest
2025-04-15 * "IRS" "Payment for 2024 tax return"
  Assets:Cash:Checking                                 -3,000.00 USD
  Expenses:Taxes:Federal:IncomeTax:Payments             3,000.00 USD
    effective_date: 2024-12-31

Hier wordt het cash‑gedeelte op 15 april 2025 geboekt, maar de kost wordt retroactief toegepast op 31 december 2024. Het resultaat is hetzelfde als Optie A, maar met een andere workflow.

Wat te doen met omzetbelasting?​

Voor de meeste persoonlijke grootboeken is omzetbelasting simpel. Als je het niet terugvordert, splits je het gewoon uit als een eigen kost tijdens een aankoop.

2025-07-19 * "Local Grocery Store"
  Expenses:Groceries                                      12.32 USD
  Expenses:Taxes:Sales                                     1.28 USD
  Assets:Cash:Checking                                   -13.60 USD

Zo kun je gemakkelijk bijhouden hoeveel je aan omzetbelasting uitgeeft gedurende het jaar. Als je een bedrijf runt dat met btw werkt, gebruik je een formeler systeem met betaal‑ en vorderingsrekeningen, maar het principe blijft hetzelfde.

Queries die je echt zult uitvoeren​

Het hele punt van deze structuur is om antwoorden makkelijk te krijgen. Hieronder enkele BQL‑queries om je belastingbeeld te zien.

1. Wat was mijn totale federale inkomstenbelasting voor 2024?

SELECT cost(sum(position))
WHERE account   "Expenses:Taxes:Federal:IncomeTax"
  AND date >= 2024-01-01 AND date < 2025-01-01;

2. Hoe splitst dat totaal zich op tussen ingehouden, betalingen en terugbetalingen?

SELECT account, cost(sum(position))
WHERE account   "Expenses:Taxes:Federal:IncomeTax"
  AND date >= 2024-01-01 AND date < 2025-01-01
GROUP BY account
ORDER BY account;

3. Heb ik nog openstaande belasting‑schulden of vorderingen? (Handig om je werk te controleren!)

SELECT account, units(sum(position))
WHERE account   "Liabilities:AccruedTaxes" OR account   "Assets:Tax"
GROUP BY account
ORDER BY account;

Als deze query niet‑nul saldi oplevert, betekent dat dat je nog accruals hebt die je niet hebt afgehandeld.

Snelle FAQ​

• Moet ik echt per‑jaar rekeningen hebben zoals Expenses:Taxes:2024?
  Waarschijnlijk niet. De accrual‑methode (of de plugin) houdt een platte rekeningsstructuur schoon en leesbaar. Maak alleen per‑jaar rekeningen als je merkt dat je specifieke queries daardoor makkelijker worden.

• Kan Beancount mijn belastingen voor me berekenen?
  Niet rechtstreeks, maar het kan de data voorbereiden. Gevorderde gebruikers schrijven scripts die BQL‑resultaten naar belasting‑calculatiesoftware sturen, wat handig is voor een schatting gedurende het jaar.

• Is dit belastingadvies?
  Nee. Dit is een boekhoudpatroon voor het organiseren van je data. De boekhouding is solide, maar raadpleeg altijd een belasting‑professional voor advies dat specifiek op jouw situatie is afgestemd.

Je kant‑klaar checklist​

Klaar om te beginnen?

1. ✅ Voeg de rekeningsstructuur toe aan je Beancount‑bestand (en pas namen aan voor jouw land).
2. ✅ Boek salarissen door te beginnen met bruto‑inkomen en vervolgens de belastingposten af te splitsen.
3. ✅ Accrue aan het einde van het jaar eventuele true‑ups voor betalingen of terugbetalingen via een liability/asset‑rekening (of gebruik de effective_date‑plugin).
4. ✅ Volg terugbetalingen als vorderingen en maak ze leeg zodra het geld binnenkomt.
5. ✅ Draai de bovenstaande BQL‑queries om je totalen te verifiëren voordat je aangifte doet.

Houd het saai, houd het consistent, en je belastingseizoen voelt eindelijk als een gewoon onderdeel van je financiële verhaal — niet als een mysterie dat je moet oplossen.

Financiële overzichten verschijnen niet uit het niets. Ze zijn het eindproduct van een gestructureerd, herhaalbaar proces dat bekend staat als de boekhoudcyclus. Hoewel de principes universeel zijn, kunnen de tools die je gebruikt de ervaring drastisch veranderen. Deze gids loopt de boekhoudcyclus met een focus op Beancount, de krachtige platte‑tekst boekhoudtool, stap voor stap door.

We laten zien hoe Beancount’s tekst‑eerste benadering saaie stappen elimineert, wat je moet automatiseren, en welke rapporten je het duidelijkst beeld van je financiële gezondheid geven. 🧑‍💻

TL;DR: De Beancount‑Werkstroom​

• Vastleggen & Journaal: Registreer elke transactie als een nette, dubbel‑postingsboeking in je .beancount‑tekstbestand.
• Valideren & Afstemmen: Gebruik balance‑asserties om te bevestigen dat je grootboek overeenkomt met bankafschriften en voer bean-check uit om fouten op te sporen.
• Controleren: Genereer een ongeregelde proefbalans voor een snelle sanity‑check.
• Aanpassen: Boeking van posten voor accruals, deferrals, afschrijvingen en andere periodieke items.
• Hercontroleren: Controleer de aangepaste proefbalans om te verzekeren dat alles correct is.
• Publiceren & Afsluiten: Genereer je winst‑en‑verliesrekening, balans en kasstroomoverzicht. Het afsluiten van de boeken is optioneel in Beancount, omdat rapporten datum‑bewust zijn.

Deze stroom kan als volgt worden gevisualiseerd:

Stap 1: Vastleggen en Registreren van Transacties​

Dit is de fundamentele stap. Elke financiële gebeurtenis — een verkoop, een aankoop, een bankvergoeding — moet worden vastgelegd. In Beancount doe je dit door transacties aan te maken in een simpel tekstbestand, meestal main.beancount of opgesplitst in meerdere bestanden per jaar.

Elke transactie moet voldoen aan de regels van dubbelboekhouding, wat betekent dat de som van alle posten nul moet zijn. Beancount dwingt dit voor je af.

2025-08-10 * "Walmart" "Aankoop kantoorbenodigdheden"
  Expenses:Office:Supplies      45.67 USD
  Assets:Bank:Checking         -45.67 USD

• Pro‑Tip: Gebruik tags zoals #project-phoenix of #client-acme om dimensies aan je data toe te voegen. Dit maakt later query‑en en rapporteren ongelooflijk flexibel.

Hygiëne bij Afstemming ✅​

De krachtigste functie voor nauwkeurigheid is de balance‑assertie. Aan het einde van een afschriftperiode (bijv. einde van de maand) geef je aan wat het saldo van een rekening zou moeten zijn.

2025-08-31 balance Assets:Bank:Checking  12345.67 USD

Als de som van alle transacties die Assets:Bank:Checking tot die datum beïnvloeden niet gelijk is aan 12345.67 USD, zal Beancount een fout melden. Deze eenvoudige directive maakt je grootboek tot een zelf‑auditend document.

Voor het achteraf invoeren van historische data kan de pad‑directive automatisch een balancerende transactie aanmaken zodat je openingssaldi overeenkomen met je eerste assertie.

Stap 2: “Boeken naar het Grootboek” (Een Gratis Stap !)​

In traditionele boekhoudsystemen schrijf je eerst posten in een “journaal” en vervolgens kopieert een aparte “posting” stap die waarden naar het “algemene grootboek”.

Met Beancount is je .beancount‑bestand zowel journaal als grootboek. Wanneer je een transactie schrijft en opslaat, heb je deze al geboekt. Er is geen aparte stap. Deze directheid is een kernvoordeel van platte‑tekst boekhouding — wat je ziet, is wat je krijgt.

Stap 3: Voorbereiden van een Ongeregelde Proefbalans​

Voordat je aanpassingen maakt, heb je een snelle “klopt dit allemaal?”‑check nodig. Een proefbalans is een simpel rapport dat elke rekening en het totale saldo weergeeft. Het totaal van alle debets moet gelijk zijn aan het totaal van alle credits.

Je kunt dit genereren met een eenvoudige query:

bean-query main.beancount \
  "SELECT account, sum(position) GROUP BY 1 ORDER BY 1"

Of, voor een visuelere aanpak, open je je grootboek in Fava (de webinterface voor Beancount) en ga je naar het “Trial Balance”‑rapport. Zoek naar ongewone zaken — een activarekening met een credit‑saldo, of een onkostenrekening met een vreemd bedrag.

Stap 4: Boeken van Aanpassingsposten​

Aanpassingsposten zijn cruciaal voor nauwkeurige rapportage volgens het accrual‑principe. Ze zorgen ervoor dat opbrengsten worden erkend wanneer ze verdiend zijn en kosten wanneer ze gemaakt zijn, ongeacht wanneer cash verandert van hand.

Veelvoorkomende aanpassingen zijn:

• Accruals: Opbrengsten die je hebt verdiend maar nog niet gefactureerd, of kosten die je hebt gemaakt maar nog niet betaald.
• Deferrals: Voorafbetalingen. Als een klant je vooruitbetaalt voor een jaar dienst, boek je dit als een verplichting (Liabilities:UnearnedRevenue) en erken je elke maand 1/12 daarvan als inkomen.
• Niet‑cash items: Boeken van zaken zoals afschrijvingen van activa.
• Correcties: Fouten herstellen of gemiste items uit bankfeeds verwerken, zoals een kleine rentebetaling.

Voorbeeld: Opbrengst Accrueren​

Je hebt een project op 31 augustus afgerond maar stuurt de factuur pas in september. Om de inkomsten in de juiste periode (augustus) te erkennen, maak je een aanpassingspost:

2025-08-31 * "Opbrengst accrual voor klantproject #1042"
  Assets:AccountsReceivable      3000.00 USD
  Income:Consulting             -3000.00 USD

Voorbeeld: Afschrijving Boeken​

Je bedrijf heeft een afschrijvingsschema voor zijn activa. Aan het einde van de periode boek je de kosten:

2025-12-31 * "Jaarlijkse afschrijving op computerapparatuur"
  Expenses:Depreciation                  4800.00 USD
  Assets:Fixed:AccumulatedDepreciation  -4800.00 USD

Stap 5: Uitvoeren van een Aangepaste Proefbalans & Validatie​

Zodra je aanpassingsposten zijn ingevoerd, voer je het proefbalans‑rapport opnieuw uit. Dit is je aangepaste proefbalans. Het levert de definitieve cijfers die worden gebruikt om de financiële overzichten te maken.

Dit is ook het perfecte moment om Beancount’s ingebouwde sanity‑check te draaien:

bean-check main.beancount

Deze opdracht controleert alle syntaxis, balanceringsregels en asserties. Als er geen output verschijnt, zijn je boeken mechanisch in orde.

Stap 6: Publiceren van Financiële Overzichten 📊​

Dit is de beloning. Met de cijfers uit je aangepaste proefbalans kun je nu de belangrijkste rapporten genereren. Fava is de makkelijkste manier, omdat het interactieve, drill‑down rapporten out‑of‑the‑box biedt.

• Winst‑en‑Verliesrekening (Profit & Loss): Toont je opbrengsten en kosten over een periode, resulterend in je netto‑inkomen of -verlies.
• Balans: Een momentopname van wat je bezit (Activa) en wat je verschuldigd bent (Passiva), evenals je eigen vermogen (Equity) op een specifieke datum.
• Kasstroomoverzicht: Verbindt je begin‑cash met je eind‑cash door te laten zien waar geld vandaan kwam en waar het naartoe ging.

Voor aangepaste rapporten kun je de Beancount Query Language (BQL) gebruiken. Hier is een query voor een maandelijkse winst‑en‑verliesrekening:

-- P&L voor augustus 2025
SELECT account, sum(position)
WHERE account   '^(Income|Expenses)'
  AND date >= 2025-08-01 AND date <= 2025-08-31
GROUP BY account ORDER BY account;

Stap 7: Boeken Afsluiten (Optioneel)​

In traditionele boekhouding omvat het “sluiten” proces het maken van journaalposten om alle tijdelijke rekeningen (Opbrengsten en Kosten) op nul te zetten en het netto‑resultaat over te dragen naar een eigen vermogen‑rekening genaamd Retained Earnings. Dit reset formeel de tijdelijke rekeningen voor het volgende jaar.

In Beancount is deze stap meestal overbodig. Fava’s rapporten zijn datum‑bewust; vraag je om een 2025 P&L, dan gebruikt het alleen 2025‑data. De saldi “lekken” niet door. De meeste gebruikers laten de saldi gewoon staan.

Mocht je echter een formele afsluiting nodig hebben voor compliance of aandeelhoudersrapportage, dan kun je dit doen met een eenvoudige einde‑jaar transactie die het totale opbrengsten‑ en kosten‑saldo naar Equity:Retained-Earnings verplaatst.

Een Praktische Maandelijkse Afsluit‑Checklist​

Hier is een herhaalbare checklist om elke maand je boeken af te sluiten met Beancount.

• Capture: Importeer alle bank‑ en creditcardtransacties. Voer handmatig eventuele contante uitgaven of buiten‑de‑band items in.
• Reconcile: Voeg balance‑asserties toe voor alle bankrekeningen, creditcards en leningen, en laat ze overeenkomen met je afschriften.
• Review: Scan de ongeregelde proefbalans in Fava. Onderzoek vreemde of onverwachte saldi. Controleer op achterstallige onbetaalde facturen (Assets:AccountsReceivable) of rekeningen (Liabilities:AccountsPayable).
• Adjust: Boeking van posten voor accrued revenue/expenses, deferred revenue, en eventuele correcties.
• Validate: Voer bean-check uit. Review de definitieve aangepaste proefbalans.
• Publish: Genereer de winst‑en‑verliesrekening en de balans. Stuur ze naar stakeholders of bewaar ze voor je administratie.
• Wrap-up: Voer optioneel een afsluitende boeking uit als je bedrijf dat vereist. Archiveer een kopie van je .beancount‑bestanden voor de periode.

Waarom Beancount Uitblinkt voor de Boekhoudcyclus​

• Transparantie en Auditability: Je grootboek is een tekstbestand. Je kunt git gebruiken om je financiële geschiedenis te versioneren, wijzigingen te bekijken met diff, en samen te werken met je accountant in een helder, eenduidig formaat.
• Volledige Controle: Jij definieert je rekeningschema. Je zit niet vast aan de structuur van een softwareleverancier. Je data zijn van jou, voor altijd, in een open formaat.
• Ongeëvenaarde Kracht: De combinatie van SQL‑achtige queries (BQL) en een rijke webinterface (Fava) geeft je ongekende mogelijkheden om je financiële data te snijden, te hakken en te begrijpen.

Kopie‑Plak‑Snippets om te Beginnen​

Eenvoudig Rekeningschema:

option "title" "My Personal Ledger"
option "operating_currency" "USD"

;; --- Accounts ---
1970-01-01 open Assets:Bank:Checking
1970-01-01 open Assets:AccountsReceivable
1970-01-01 open Liabilities:CreditCard
1970-01-01 open Liabilities:UnearnedRevenue
1970-01-01 open Equity:Owner:Capital
1970-01-01 open Equity:Retained-Earnings
1970-01-01 open Income:Consulting
1970-01-01 open Expenses:Office:Supplies
1970-01-01 open Expenses:Software
1970-01-01 open Expenses:Depreciation

Handige BQL‑Query:

-- Find all customers with an outstanding balance
SELECT payee, sum(position)
WHERE account = 'Assets:AccountsReceivable'
GROUP BY payee
HAVING sum(position) > 0
ORDER BY sum(position) DESC;

Door de tijdloze boekhoudcyclus te koppelen aan Beancount’s moderne, tekst‑gebaseerde tools, krijg je een systeem dat robuust, transparant en gebouwd is om lang mee te gaan. Happy bookkeeping!

Decennialang werd de wereld van bedrijfsboekhouding gedomineerd door een bekende reeks gesloten, GUI-gebaseerde systemen zoals QuickBooks, Xero en FreshBooks. Zij hebben de standaard gezet en bieden gebruiksgemak en visuele workflows die geschikt zijn voor niet-technische gebruikers. Maar voor ontwikkelaars, ervaren gebruikers en iedereen die absolute transparantie en controle waardeert, is er een radicaal andere aanpak ontstaan: Beancount.io.

Dit artikel biedt een directe vergelijking van Beancount.io met traditionele boekhoudsoftware. We zullen hun belangrijkste verschillen in filosofie, flexibiliteit, kosten en onderhoudbaarheid op lange termijn uiteenzetten om je te helpen beslissen welk systeem echt bij jouw behoeften past.

1. Filosofie en Workflow​

Het meest fundamentele verschil tussen deze twee benaderingen ligt in hun kernfilosofie.

Beancount.io Beancount.io is gebouwd op de filosofie van platte-tekstboekhouding. In de kern is elke financiële transactie een invoer in een eenvoudig tekstbestand. Dit "boekhouden als code"-model geeft prioriteit aan leesbare, versiebeheerde records. Jouw financiële gegevens bevinden zich in een tijdloos, open formaat dat volledig van jou is - het kan nooit worden afgesloten door een leverancier. Deze workflow is ontworpen voor gebruikers die vertrouwd zijn met code-editors, versiebeheersystemen zoals Git en command-line tools.

Traditionele Software Traditionele boekhoudplatforms zijn GUI-gebaseerd en formuliergestuurd. Je voert gegevens in met behulp van wizards, dropdown-menu's en visuele formulieren. Deze aanpak geeft prioriteit aan directheid en toegankelijkheid, waardoor het voor niet-technische gebruikers gemakkelijk is om aan de slag te gaan zonder een steile leercurve. Jouw gegevens worden echter opgeslagen in een eigen formaat of een cloud-database, wat vaak complexe export- en importprocedures vereist als je ooit besluit om over te stappen naar een andere service.

Conclusie: Als je prioriteit geeft aan volledige controle, gegevenseigendom, transparantie en automatisering, is Beancount.io de duidelijke winnaar. Als je een "klik en ga"-interface nodig hebt met een minimale leercurve, zal traditionele software natuurlijker aanvoelen.

2. Flexibiliteit en Aanpassing​

Hoe goed kan de software zich aanpassen aan jouw specifieke behoeften?

Beancount.io 100% scriptbaar zijn is de superkracht van Beancount.io. Het integreert naadloos met Python, waardoor je verbinding kunt maken met elke API, het ophalen van gegevens uit bankfeeds kunt automatiseren, transacties programmatisch kunt taggen op basis van complexe regels en aangepaste rapporten kunt genereren die zijn afgestemd op jouw exacte specificaties. Jouw vermogen om uit te breiden en aan te passen is praktisch oneindig, vrij van door leveranciers opgelegde beperkingen.

Traditionele Software Deze platforms bieden een samengestelde selectie van integraties met populaire tools zoals PayPal, Stripe en verschillende payroll-services. Hoewel handig, opereer je binnen de ommuurde tuin van de leverancier. Aanpassing is beperkt tot wat het platform toestaat, en geavanceerde rapportage of automatisering vereist vaak een upgrade naar een hoger abonnement of de aankoop van add-ons van derden. Je kunt met hun API's werken, maar je zult altijd gebonden zijn aan de regels en snelheidslimieten van hun ecosysteem.

Conclusie: Beancount.io biedt ongeëvenaarde flexibiliteit voor ontwikkelaars en technische gebruikers. Traditionele tools zijn beter geschikt voor standaard plug-and-play workflows met populaire zakelijke applicaties.

3. Samenwerking en Transparantie​

Hoe je met anderen samenwerkt en je gegevens controleert, verschilt aanzienlijk.

Beancount.io Samenwerking aan Beancount.io wordt beheerd via Git. Dit maakt elke wijziging in jouw financiële grootboek volledig transparant en controleerbaar. Je kunt zien wie wat, wanneer en waarom heeft gewijzigd - net als een code review workflow. Dit is ideaal voor gedistribueerde teams die al tools zoals GitHub of GitLab gebruiken. Bovendien zijn er geen verborgen berekeningen; elk getal in een rapport kan worden herleid tot de exacte regelinvoer in jouw grootboekbestand, waardoor volledige controleerbaarheid wordt gegarandeerd.

Traditionele Software Samenwerking wordt afgehandeld via ingebouwde gebruikersrollen en machtigingen. Je kunt je accountant, boekhouder of zakelijke partners uitnodigen om de boeken rechtstreeks te openen via de webinterface. Dit is zeer effectief voor bedrijven die een traditioneel model van financieel toezicht volgen. Het nadeel is dat sommige interne bewerkingen, zoals belastingberekeningen of geautomatiseerde saldo-aanpassingen, ondoorzichtige "black boxes" kunnen zijn, waardoor het moeilijk is om de logica onafhankelijk te verifiëren.

Conclusie: Beancount.io is perfect voor teams die granulariteit, controleerbaarheid en samenwerking in code-stijl waarderen. Traditionele systemen zijn accountantvriendelijker voor realtime, gedeelde GUI-toegang.

4. Kosten en Eigendom​

De financiële modellen en het concept van gegevenseigendom zijn wereldwijd verschillend.

Beancount.io De kern Beancount-software is open-source en gratis. Je betaalt alleen voor de diensten met toegevoegde waarde van Beancount.io, waaronder hosting, intelligente automatisering en premium functies. Er zijn geen licentiekosten per gebruiker, dus je kunt je team schalen zonder extra kosten. Het belangrijkste is dat er geen vendor lock-in is. Jouw gegevens zijn een verzameling tekstbestanden die je altijd en overal kunt verplaatsen, bewerken of opslaan.

Traditionele Software Deze services werken op basis van een abonnementsmodel, meestal maandelijks of jaarlijks gefactureerd. Prijzen zijn vaak gelaagd op basis van functies en je kunt te maken krijgen met kosten per gebruiker of per bedrijf die meeschalen met je organisatie. Dit creëert een afhankelijkheid; als je stopt met betalen, loop je het risico de toegang tot je gegevens en de functionaliteit van de software te verliezen. Deze vendor lock-in is een aanzienlijk risico op lange termijn.

Conclusie: Beancount.io is aanzienlijk kosteneffectiever op de lange termijn, vooral voor technische teams die gegevenssoevereiniteit waarderen. Traditionele software biedt voorspelbare abonnementskosten, maar creëert afhankelijkheid op lange termijn.

5. Leercurve en Adoptie​

Hoe snel kun je aan de slag?

Beancount.io De leercurve is onmiskenbaar steiler. Het adopteren van dit systeem vereist comfort met tekstgebaseerd bewerken, begrip van basis-syntax en vertrouwdheid met tools zoals Git. De initiële investering loont echter. Eenmaal onder de knie, maakt Beancount ongelooflijk snelle, herhaalbare workflows mogelijk en biedt het een veel dieper, fundamenteel begrip van jouw financiële plaatje.

Traditionele Software Deze platforms zijn ontworpen voor niet-technische bedrijfseigenaren en bieden minimale onboarding-wrijving. Je kunt binnen enkele minuten aan de slag met het verzenden van facturen en het categoriseren van uitgaven. Dat gezegd hebbende, vereist het leren van de meer geavanceerde functies, zoals het bouwen van aangepaste rapporten of het opzetten van multi-entity accounting, nog steeds een aanzienlijke tijdsinvestering.

Conclusie: Beancount.io is de juiste keuze als je bereid bent om tijd te investeren in het leren van een krachtig systeem. Traditionele software is sneller om mee te starten voor niet-technische gebruikers die direct resultaten nodig hebben.

Vergelijking Zij aan Zij

Wanneer Kies je Welke

De beslissing komt uiteindelijk neer op de vaardigheden, prioriteiten en workflow van jouw team.

Kies Beancount.io als je:

• Een ontwikkelaar, data-analist of technisch aangelegde ervaren gebruiker bent.
• Absolute transparantie, controle en gegevensportabiliteit op lange termijn boven alles waardeert.
• Je boekhouding volledig wilt automatiseren en diep wilt integreren in je aangepaste workflows.
• Je financiële gegevens met dezelfde strengheid wilt behandelen als broncode.

Kies Traditionele Boekhoudsoftware als je:

• Een snelle start, visuele interface zonder technische setup wilt.
• Direct, accountantvriendelijke toegang met minimale training moet bieden.
• De voorkeur geeft aan een beheerde, gehoste oplossing waarbij de leverancier alle updates en compliance afhandelt.
• Je integratiebehoeften worden voldaan door populaire, kant-en-klare apps.

Laatste Gedachten

Beancount.io probeert geen betere QuickBooks te zijn - het is een fundamenteel andere manier van denken. Het vertegenwoordigt boekhouden als code. Voor technische professionals biedt deze verschuiving dezelfde sprong voorwaarts die versiebeheer met Git bracht voor softwareontwikkeling: volledige transparantie, perfecte reproduceerbaarheid en ultieme controle.

Tegelijkertijd blijft traditionele boekhoudsoftware winnen op het gebied van gebruiksgemak en kant-en-klare integraties voor niet-technische teams. De juiste keuze gaat niet over welke "beter" is in het algemeen, maar welke perfect past bij jouw workflow, jouw prioriteiten en de mate van controle die je eist over jouw financiële gegevens.

Kernfunctionaliteit en Filosofie van Beancount​

Beancount is een open-source dubbel boekhoudsysteem dat platte tekstbestanden gebruikt om transacties vast te leggen. In de kern behandelt Beancount uw grootboek als een dataset gedefinieerd door een eenvoudige, strikte grammatica. Elke financiële gebeurtenis (transacties, rekeningopeningen, grondstofprijzen, enz.) is een richtlijn in een tekstbestand, die Beancount parseert naar een in-memory database van boekingen. Dit ontwerp handhaaft het principe van dubbele boekhouding: elke transactie moet debets en credits over rekeningen in balans brengen. Het resultaat is een zeer transparant en controleerbaar grootboek dat u gemakkelijk kunt beheren met versiebeheer, inspecteren en opvragen.

Filosofie – correctheid en minimalisme: Het ontwerp van Beancount geeft prioriteit aan gegevensintegriteit en eenvoud. De maker, Martin Blais, beschrijft Beancount als "pessimistisch" in de veronderstelling dat de gebruiker fouten zal maken en legt daarom extra controles en beperkingen op. Beancount staat u bijvoorbeeld niet toe activa te verwijderen die nooit zijn toegevoegd (waardoor negatieve voorraadposities of kassaldi worden voorkomen) en kan afdwingen dat elke rekening geopend is voor gebruik. Het mist het concept van "virtuele" of automatisch gebalanceerde boekingen van Ledger – een bewuste keuze om volledig gebalanceerde boekingen af te dwingen. Beancount zet vol in op correctheid met meer kruiscontroles dan de basis dubbele boekhouding biedt. Deze voorzichtige benadering spreekt gebruikers aan die "zichzelf niet te veel vertrouwen" en willen dat de software hun fouten opvangt.

Minimale opties, maximale consistentie: In tegenstelling tot Ledgers talloze commandoregelvlaggen en afstemmingsopties, kiest Beancount voor minimalisme. Er zijn zeer weinig globale opties, en geen die de transactiesemantiek buiten het grootboekbestand wijzigen. Alle configuratie die de boekhouding beïnvloedt (zoals kostprijsmethoden voor grondstoffen of boekingsaannames) gebeurt in-bestand via richtlijnen of plugins, wat ervoor zorgt dat het laden van hetzelfde bestand altijd dezelfde resultaten oplevert, ongeacht hoe rapporten worden gegenereerd. Dit ontwerp vermijdt de complexiteit van Ledgers vele instellingen en de subtiele interacties daartussen. De filosofie van Beancount is dat een boekhoudtool een stabiele, deterministische pijplijn moet zijn van invoerbestand naar rapporten. Dit wordt bereikt door het grootboek te behandelen als een geordende stroom van richtlijnen die programmatisch opeenvolgend kunnen worden verwerkt. Zelfs zaken die Ledger als speciale syntaxis behandelt (zoals beginbalansen of prijsopgaven) zijn eersteklas richtlijnen in het gegevensmodel van Beancount, wat het systeem zeer uitbreidbaar maakt.

Uitbreidbaarheid via plugins en querytaal: Beancount is geïmplementeerd in Python en biedt hooks om aangepaste logica in de verwerkingspijplijn te injecteren. Gebruikers kunnen plugins in Python schrijven die werken op de stroom van transacties (bijvoorbeeld om een aangepaste regel af te dwingen of automatische boekingen te genereren). Deze plugins draaien terwijl het bestand wordt verwerkt, waardoor de kernfunctionaliteit van Beancount effectief wordt uitgebreid zonder de broncode te hoeven wijzigen. Beancount bevat ook een krachtige querytaal (geïnspireerd op SQL) om het grootboek te analyseren en te filteren. De bean-query tool behandelt het geparseerde grootboek als een database en stelt u in staat er analytische queries op uit te voeren – bijvoorbeeld uitgaven per categorie op te tellen of alle transacties voor een bepaalde begunstigde te extraheren. In Beancount 3.x is deze querymogelijkheid verplaatst naar een standalone beanquery pakket, maar vanuit gebruikersperspectief biedt het nog steeds flexibele rapportage via SQL-achtige queries.

Platte tekst en versiebeheer: Als een platte tekst boekhoudtool benadrukt Beancount gebruikerscontrole en de levensduur van gegevens. Het grootboek is simpelweg een .beancount tekstbestand dat u in elke teksteditor kunt bewerken. Dit betekent dat uw hele financiële geschiedenis in een menselijk leesbare vorm wordt opgeslagen, en u kunt het in Git of een ander VCS plaatsen om wijzigingen in de loop van de tijd bij te houden. Gebruikers houden hun Beancount-bestand vaak onder versiebeheer om een audit trail van elke bewerking bij te houden (met commit-berichten die wijzigingen beschrijven). Deze benadering komt overeen met de filosofie van Beancount dat boekhoudgegevens, vooral persoonlijke of kleine zakelijke financiën, transparant en "toekomstbestendig" moeten zijn – niet opgesloten in een eigen database. In de woorden van Martin Blais zelf is Beancount een "liefdeswerk" gebouwd om eenvoudig, duurzaam en gratis te zijn voor de gemeenschap. Het werd voor het eerst ontwikkeld rond 2007 en is geëvolueerd door grote herzieningen (v1 naar v2, en nu v3 in 2024) om het ontwerp te verfijnen terwijl de kernfilosofie van minimalisme en correctheid behouden bleef.

Hulpmiddelen, Plugins en Extensies in het Beancount Ecosysteem​

Het Beancount ecosysteem heeft een rijke verzameling aan hulpmiddelen, plugins en extensies ontwikkeld die de kernfunctionaliteit van het grootboek verbeteren. Deze omvatten het importeren van gegevens, het bewerken van grootboeken, het bekijken van rapporten en het toevoegen van gespecialiseerde boekhoudfuncties. Hieronder vindt u een overzicht van belangrijke componenten en add-ons in de Beancount wereld:

Hulpprogramma's voor gegevensimport (Importers)​

Een van de belangrijkste behoeften voor praktisch gebruik is het importeren van transacties van banken, creditcards en andere financiële instellingen. Beancount biedt hiervoor een importframework en door de community bijgedragen importscripts. In Beancount 2.x werd de ingebouwde module beancount.ingest (met commando's zoals bean-extract en bean-identify) gebruikt om importer-plugins in Python te definiëren en toe te passen op gedownloade afschriften. In Beancount 3.x is dit vervangen door een extern project genaamd Beangulp. Beangulp is een toegewijd importersframework dat is geëvolueerd uit beancount.ingest en is nu de aanbevolen manier om transactie-import voor Beancount 3.0 te automatiseren. Het maakt het mogelijk om Python-scripts of commandoregeltools te schrijven die externe bestanden (zoals CSV- of PDF-afschriften) lezen en Beancount-boekingen uitvoeren. Deze nieuwe aanpak ontkoppelt de importlogica van de Beancount-kern – zo is het oude bean-extract-commando verwijderd in v3, en produceren uw importscripts in plaats daarvan zelf transacties via de CLI-interface van Beangulp.

Tientallen kant-en-klare importers bestaan voor verschillende banken en formaten, bijgedragen door de community. Er zijn importscripts voor instellingen over de hele wereld – van Alipay en WeChat Pay in China, tot diverse Europese banken (Commerzbank, ING, ABN AMRO, etc.), tot Amerikaanse banken zoals Chase en Amex. Veel hiervan zijn verzameld in openbare repositories (vaak op GitHub) of in pakketten zoals beancount-importers. Zo biedt het project Tarioch Beancount Tools (tariochbctools) importers voor Zwitserse en Britse banken en verwerkt het zelfs crypto-transactie-imports. Een ander voorbeeld is Lazy Beancount, dat een reeks veelvoorkomende importers bundelt (voor Wise, Monzo, Revolut, IBKR, etc.) en een Docker-gebaseerde setup biedt voor eenvoudige automatisering. Welke bank of financiële dienst u ook gebruikt, de kans is groot dat iemand er al een Beancount-importer voor heeft geschreven – of u kunt uw eigen importer schrijven met behulp van het framework van Beangulp. De flexibiliteit van Python betekent dat importers CSV/Excel-bestanden, OFX/QIF-downloads of zelfs het scrapen van API's kunnen verwerken, en vervolgens transacties kunnen uitvoeren in gestandaardiseerd Beancount-formaat.

Bewerken en Integratie met Editors​

Omdat Beancount grootboeken gewoon tekstbestanden zijn, maken gebruikers vaak gebruik van hun favoriete teksteditors of IDE's om ze te onderhouden. Het ecosysteem biedt plugins voor editorondersteuning om deze ervaring soepeler te maken. Er zijn extensies voor veel populaire editors die syntaxiskleuring, automatische aanvulling van rekeningnamen en real-time foutcontrole toevoegen:

• Emacs Beancount-Modus: Een Emacs major mode (beancount-mode) is beschikbaar om .beancount-bestanden te bewerken, en biedt functies zoals syntaxiskleuring en integratie met de Beancount-controleur. Het kan zelfs bean-check op de achtergrond uitvoeren, zodat fouten in het grootboek (zoals een onuitgebalanceerde transactie) worden gemarkeerd terwijl u bewerkt.
• VS Code Extensie: Een Beancount-extensie op de VSCode Marketplace biedt vergelijkbare gemakken voor Visual Studio Code-gebruikers. Het ondersteunt syntaxiskleuring, uitlijning van bedragen, automatische aanvulling voor rekeningen/begunstigden, en zelfs on-the-fly saldocontroles wanneer u het bestand opslaat. Het kan ook integreren met Fava, waardoor u de Fava-webinterface vanuit VSCode kunt starten.
• Plugins of modi bestaan ook voor Vim, Atom en andere editors. Er is bijvoorbeeld een Tree-sitter grammatica voor Beancount, die syntaxiskleuring in moderne editors mogelijk maakt en zelfs is overgenomen in de webgebaseerde editorcomponent van Fava. Kortom, wat uw bewerkingsomgeving ook is, de community heeft waarschijnlijk een plugin geleverd om het bewerken van Beancount-bestanden gemakkelijk en foutloos te maken.

Voor snelle invoer van transacties buiten traditionele editors, zijn er ook tools zoals Bean-add en mobiele apps. Bean-add is een commandoregeltool die het toevoegen van een nieuwe transactie via een prompt of één-regelige opdracht mogelijk maakt, met ondersteuning voor datum- en rekeningsuggesties. Op mobiel biedt een project genaamd Beancount Mobile een eenvoudige interface om transacties onderweg in te voeren (bijvoorbeeld het vastleggen van een contante aankoop vanaf uw telefoon). Bovendien bestaat er een Beancount Telegram Bot om transacties vast te leggen via berichten – u kunt een bericht sturen met transactiedetails, en de bot formatteert het in uw grootboekbestand.

Webfrontends en Visualisatietools​

(Fava) Fava's webinterface biedt een interactief dashboard voor Beancount, met rapporten zoals een winst- en verliesrekening met visualisaties (hier weergegeven als een treemap van uitgaven per categorie) naast tabellen van rekeningen en saldi.

De belangrijkste frontend voor Beancount is Fava, een moderne webinterface. Fava draait als een lokale webapplicatie die uw Beancount-bestand leest en een rijke, interactieve ervaring in uw browser biedt. Het biedt een complete reeks rapporten: balans, winst- en verliesrekening, vermogen over tijd, portefeuilleposities, prestatiegrafieken, budgetten en meer – allemaal direct beschikbaar. Gebruikers noemen Fava vaak als een belangrijke reden om Beancount te verkiezen boven andere plain-text boekhoudtools. Met één enkel commando (fava ledger.beancount) kunt u uw financiën bekijken met grafieken en tabellen in plaats van tekst. Fava ondersteunt functies zoals: inzoomen op rekeningen, transacties filteren op begunstigde of tag, een query-editor (zodat u Beancount-queries kunt uitvoeren en de resultaten in de browser kunt zien), en zelfs een geïntegreerde webgebaseerde editor voor uw grootboek. Het is zeer gebruiksvriendelijk, waardoor plain-text boekhouden toegankelijk wordt voor degenen die visuele interfaces verkiezen.

Onder de motorkap is Fava geschreven in Python (Flask aan de backend) en JavaScript (Svelte aan de frontend). Het heeft een eigen releasecyclus en wordt actief onderhouden. Met name heeft Fava gelijke tred gehouden met de ontwikkeling van Beancount – zo heeft Fava 1.30 ondersteuning toegevoegd voor Beancount v3, waarbij intern is overgestapt op het gebruik van de nieuwe beanquery- en beangulp-pakketten. (Het ondersteunt nog steeds Beancount 2 voor oudere grootboeken.) Fava's focus op gebruiksvriendelijkheid omvat fijne details zoals auto-aanvullen in de webeditor, en een strakke gebruikersinterface met een donkere modus en responsieve grafieken. Er is ook een spin-off genaamd Fava-GTK, die Fava verpakt in een desktopapplicatie voor GNOME/Linux-gebruikers die de voorkeur geven aan het gevoel van een native app.

Naast Fava bestaan er andere visualisatie- en analyseopties. Omdat Beancount-gegevens kunnen worden geëxporteerd of opgevraagd als tabellen, maken gebruikers vaak gebruik van tools zoals Jupyter-notebooks of Pandas voor aangepaste analyse. Een gebruiker beschrijft bijvoorbeeld hoe gegevens uit Beancount via de query-interface in een Pandas DataFrame worden geladen om een aangepast rapport voor te bereiden. Er zijn ook door de community bijgedragen scripts voor specifieke rapporten – bijvoorbeeld een tool voor portefeuilleallocatieanalyse of een procesbeheersingsgrafiek voor uitgaven versus vermogen. Voor de meeste mensen biedt Fava echter meer dan voldoende rapportagemogelijkheden zonder dat er code geschreven hoeft te worden. Het ondersteunt zelfs extensies: u kunt Python-bestanden toevoegen die nieuwe rapportpagina's of grafieken aan Fava toevoegen. Een opmerkelijke extensie is fava-envelope voor envelopbudgettering binnen Fava. Over het algemeen dient Fava als de centrale visualisatiehub van het Beancount-ecosysteem.

Hulpprogramma's en scripts voor de opdrachtregel​

Beancount wordt geleverd met diverse CLI-hulpprogramma's (vooral in de oudere v2-branch, waarvan sommige zijn ingekort in v3). Deze hulpprogramma's werken op uw grootboekbestand om het te controleren of specifieke rapporten in tekst of HTML te genereren:

• bean-check: een validator die controleert op syntaxisfouten of boekhoudkundige fouten in het bestand. Het uitvoeren van bean-check myfile.beancount waarschuwt u voor elke onbalans, ontbrekende rekening of andere problemen, en geeft niets weer als het bestand foutloos is.
• bean-format: een formatter die uw grootboek netjes maakt door getallen uit te lijnen in overzichtelijke kolommen, vergelijkbaar met het uitvoeren van een code-formatter op broncode. Dit helpt het bestand schoon en leesbaar te houden.
• bean-query: een interactieve shell of batch-hulpprogramma om Beancounts querytaal op uw grootboek uit te voeren. U kunt het gebruiken om aangepaste tabelrapporten te produceren (bijv. bean-query myfile.beancount "SELECT account, sum(amount) WHERE ...").
• bean-report: een veelzijdige rapportgenerator (in v2) die vooraf gedefinieerde rapporten (balans, winst- en verliesrekening, proefbalans, enz.) kan uitvoeren naar de console of naar bestanden. Bijvoorbeeld, bean-report file.beancount balances zou rekeningsaldi afdrukken. (In de praktijk zijn veel van deze tekstrapporten vervangen door de mooiere presentatie van Fava.)
• bean-web / bean-bake: een oudere webinterface die de rapporten op localhost zou aanbieden of ze zou "bakken" als statische HTML-bestanden. Deze werden voornamelijk gebruikt voordat Fava populair werd; bean-web bood een basis webweergave van dezelfde rapporten die bean-report kon genereren. In Beancount 3 is bean-web verwijderd (aangezien Fava nu de aanbevolen web-frontend is, die een superieure ervaring biedt).
• bean-example: een hulpprogramma om een voorbeeld grootboekbestand te genereren (nuttig voor nieuwkomers om een sjabloon van Beancount-boekingen te zien).
• bean-doctor: een debug-hulpprogramma dat problemen in uw grootboek of omgeving kan diagnosticeren.

Het is vermeldenswaard dat met Beancount v3, veel van deze hulpprogramma's uit het kernproject zijn verplaatst. Het kernpakket van Beancount werd gestroomlijnd, en hulpprogramma's zoals de query-engine en importeurs werden opgesplitst in afzonderlijke pakketten (beanquery, beangulp, enz.) voor eenvoudiger onderhoud. De functionaliteit van bean-query wordt bijvoorbeeld nu geleverd door het beanquery-hulpprogramma dat afzonderlijk wordt geïnstalleerd. Vanuit het perspectief van de gebruiker blijft de functionaliteit beschikbaar; het is alleen gemodulariseerd. De Arch Linux-gemeenschap merkte deze verandering op bij het updaten van Fava: het Fava-pakket voegde afhankelijkheden toe aan beanquery en beangulp om Beancount 3.x te ondersteunen. Deze modulaire aanpak stelt ook anderen in de gemeenschap in staat om onafhankelijker van de releasecyclus van Beancount bij te dragen aan deze hulp-hulpprogramma's.

Beancount Plugins en Extensies​

Een opvallende kracht van het Beancount-ecosysteem is het plugin-systeem. Door een regel plugin "module.name" toe te voegen aan uw Beancount-bestand, kunt u aangepaste Python-logica opnemen die wordt uitgevoerd tijdens de verwerking van het grootboek. De community heeft veel plugins gemaakt om de mogelijkheden van Beancount uit te breiden:

• Gegevenskwaliteit en regels: Voorbeelden zijn beancount-balexpr waarmee u vergelijkingen met meerdere rekeningen kunt bevestigen (bijv. Activa A + Activa B = Passiva X), en beancount-checkclosed dat automatisch saldobevestigingen invoegt wanneer u een rekening afsluit om ervoor te zorgen dat deze op nul uitkomt. Er is zelfs een plugin om ervoor te zorgen dat transacties in het bestand op datum zijn gesorteerd (autobean.sorted) om ongesorteerde invoer te detecteren.
• Automatisering: De beancount-asset-transfer plugin kan in-natura overboekingen genereren tussen rekeningen (handig voor het verplaatsen van aandelen tussen makelaars met behoud van de kostprijs). Een andere, autobean.xcheck, controleert uw Beancount-grootboek aan de hand van externe afschriften op afwijkingen.
• Terugkerende transacties en budgetten: De “repeat” of interpolate plugin van Akuukis maakt het mogelijk om terugkerende transacties te definiëren of een jaarlijkse uitgave over maanden te spreiden. Voor budgettering ondersteunt de fava-envelope extensie (gebruikt via Fava) de envelopbudgetteringsmethode in platte tekst. Er is ook MiniBudget van Frank Davies – een kleine, op zichzelf staande tool geïnspireerd op Beancount om te helpen bij budgettering voor persoonlijk of klein zakelijk gebruik.
• Belasting en rapportage: Sommige plugins helpen bij belastingboekhouding, zoals een die vermogenswinsten automatisch classificeert in korte versus lange termijn. Een andere (fincen_114 van Justus Pendleton) genereert een FBAR-rapport voor Amerikaanse belastingbetalers met buitenlandse rekeningen, wat illustreert hoe Beancount-gegevens kunnen worden benut voor regelgevende rapportage.
• Community plugin repositories: Er zijn samengestelde plugin-sets zoals beancount-plugins (van Dave Stephens) gericht op zaken als afschrijvingsposten, en beancount-plugins-zack (van Stefano Zacchiroli) die diverse hulpmiddelen bevatten, zoals sorteerrichtlijnen.

Naast plugins pakken andere hulpprogramma's rondom Beancount specifieke behoeften aan. Zo is beancount-black een auto-formatter vergelijkbaar met de Black code formatter, maar dan voor Beancount grootboekbestanden. Er is een Beancount Bot (Telegram/Mattermost) voor het toevoegen van transacties via chat, zoals vermeld, en een Alfred workflow voor macOS om snel transacties aan uw bestand toe te voegen. Een tool genaamd Pinto biedt een "supercharged" CLI met interactieve invoer (zoals een verbeterde bean-add). Voor degenen die migreren van andere systemen, bestaan er converters (YNAB2Beancount, CSV2Beancount, GnuCash2Beancount, Ledger2Beancount) om gegevens van elders in te voeren.

Samenvattend is het Beancount-ecosysteem behoorlijk uitgebreid. Tabel 1 hieronder vermeldt enkele belangrijke tools en extensies met hun rollen:

| Converters (Migratietools) | Hulpprogramma's om gegevens van andere formaten naar Beancount te converteren, bijv. van GnuCash of Ledger CLI naar Beancount-formaat. Vergemakkelijken de adoptie van Beancount zonder helemaal opnieuw te beginnen. |

Vergelijking met Ledger, hledger en vergelijkbare systemen​

Beancount behoort tot de familie van platte-tekst dubbel boekhouden tools, waarvan Ledger CLI (John Wiegley’s Ledger) en hledger de meest prominente zijn. Hoewel al deze systemen het kernidee van platte-tekst grootboekbestanden en dubbel boekhouden delen, verschillen ze in syntaxis, filosofie en ecosysteemvolwassenheid. De volgende tabel belicht de belangrijkste verschillen tussen Beancount, Ledger en hledger:

Gebruiksscenario's voor Beancount​

Beancount is veelzijdig genoeg om te worden gebruikt voor het bijhouden van persoonlijke financiën, alsook (in sommige gevallen) voor de boekhouding van kleine bedrijven. De kern van de dubbelboekhoudkundige benadering is in beide scenario's hetzelfde, maar de schaal en specifieke praktijken kunnen verschillen.

Persoonlijke Financiën​

Veel Beancount-gebruikers zetten het in om hun persoonlijke of huishoudelijke financiën te beheren. Een typische persoonlijke financiële opzet in Beancount kan rekeningen omvatten voor betaal- en spaarrekeningen, creditcards, beleggingen, leningen, inkomstencategorieën (salaris, rente, etc.) en uitgavencategorieën (huur, boodschappen, entertainment, etc.). Gebruikers registreren dagelijkse transacties handmatig (door kwitanties, facturen, etc. in te voeren) of door ze te importeren vanuit bankafschriften met behulp van de eerder besproken importtools. De voordelen die Beancount biedt voor persoonlijke financiën zijn:

• Consolidatie en Analyse: Al uw transacties kunnen in één tekstbestand (of een set bestanden) staan dat jarenlange financiële geschiedenis vertegenwoordigt. Dit maakt het eenvoudig om langetermijntrends te analyseren. Met de querytaal van Beancount of met Fava kunt u binnen enkele seconden vragen beantwoorden als "Hoeveel heb ik de afgelopen 5 jaar aan reizen uitgegeven?" of "Wat is mijn gemiddelde maandelijkse boodschappenrekening?". Eén gebruiker merkte op dat na de overstap naar Beancount, "analyse van financiële gegevens (uitgaven, giften, belastingen, etc.) triviaal is" , zowel via Fava als door de gegevens op te vragen en tools zoals Pandas te gebruiken. In wezen wordt uw grootboek een persoonlijke financiële database die u naar believen kunt bevragen.
• Budgettering en Planning: Hoewel Beancount geen budgetteringssysteem afdwingt, kunt u er wel een implementeren. Sommige gebruikers doen aan envelopbudgettering door budgetrekeningen aan te maken of de fava-envelope plugin te gebruiken. Anderen gebruiken eenvoudigweg periodieke rapporten om uitgaven te vergelijken met doelen. Omdat het platte tekst is, is de integratie van Beancount met externe budgetteringstools of spreadsheets eenvoudig (gegevens exporteren of CSV-uitvoer van queries gebruiken).
• Beleggingen en Netto Waarde Tracking: Beancount blinkt uit in het bijhouden van beleggingen dankzij de robuuste afhandeling van kostprijzen en marktprijzen. U kunt aan- en verkopen van aandelen, crypto, etc. vastleggen met kostendetails, en vervolgens Prices-richtlijnen gebruiken om de marktwaarde bij te houden. Fava kan een grafiek van de netto waarde over tijd en een portefeuilleoverzicht per activaklasse tonen. Dit is enorm nuttig voor persoonlijk vermogensbeheer – u krijgt inzichten die vergelijkbaar zijn met wat commerciële tools zoals Mint of Personal Capital bieden, maar dan volledig onder uw controle. Valutabeheer is ook ingebouwd, dus als u buitenlandse valuta's of crypto aanhoudt, kan Beancount deze bijhouden en converteren voor rapportage.
• Afstemming en Nauwkeurigheid: Persoonlijke financiën omvatten vaak het afstemmen met bankafschriften. Met Beancount kan men rekeningen regelmatig afstemmen door gebruik te maken van saldo-asserties of de documentenfunctie. Zo kunt u bijvoorbeeld elke maand een balance Assets:Bank:Checking <datum> <saldo>-regel toevoegen om te bevestigen dat uw grootboek overeenkomt met het bankafschrift aan het einde van de maand. De bean-check tool (of Fava's foutweergave) zal u waarschuwen als dingen niet kloppen. Eén gebruiker noemt het maandelijks afstemmen van alle rekeningen, wat "helpt om ongebruikelijke activiteit te detecteren" – een goede persoonlijke financiële hygiënepraktijk die Beancount faciliteert.
• Automatisering: Technisch onderlegde individuen hebben grote delen van hun persoonlijke financiële workflow geautomatiseerd met Beancount. Met behulp van importtools, cron-taken en misschien een beetje Python, kunt u uw systeem zo instellen dat bijvoorbeeld elke dag uw banktransacties worden opgehaald (sommigen gebruiken OFX of API's) en aan uw Beancount-bestand worden toegevoegd, gecategoriseerd door regels. Na verloop van tijd wordt uw grootboek grotendeels automatisch bijgewerkt, en hoeft u alleen nog maar te controleren en aan te passen waar nodig. Een communitylid op Hacker News deelde dat na 3 jaar hun Beancount-boekhouding "95% automatisch" was. Dit niveau van automatisering is mogelijk dankzij de openheid van Beancount's platte tekst en de scriptmogelijkheden.

Gebruikers van persoonlijke financiën kiezen Beancount vaak boven spreadsheets of apps omdat het hen volledig eigendom van de gegevens geeft (geen afhankelijkheid van een cloudservice die mogelijk wordt stopgezet – een zorg nu Mint bijvoorbeeld is stopgezet) en omdat de diepte van het inzicht groter is wanneer u al uw gegevens geïntegreerd hebt. De leercuve is niet triviaal – men moet basisboekhouding en de Beancount-syntaxis leren – maar bronnen zoals de officiële documentatie en community-tutorials helpen nieuwkomers op weg. Eenmaal ingesteld, vinden velen dat het gemoedsrust geeft om te allen tijde een duidelijk, betrouwbaar beeld van hun financiën te hebben.

Boekhouding voor kleine bedrijven​

Het gebruik van Beancount voor een klein bedrijf (of non-profit, vereniging, etc.) is minder gebruikelijk dan voor persoonlijk gebruik, maar het is zeker mogelijk en sommigen hebben het met succes gedaan. Het dubbelboekhoudingskader van Beancount is in feite hetzelfde systeem dat ten grondslag ligt aan bedrijfsboekhouding, alleen zonder enkele van de geavanceerdere functies die gespecialiseerde boekhoudsoftware biedt (zoals facturatiemodules of salarisadministratie-integraties). Zo past Beancount in een kleine bedrijfscontext:

• Grootboek en financiële overzichten: Een klein bedrijf kan het Beancount-bestand behandelen als zijn grootboek. Je zou activarekeningen hebben voor bankrekeningen, debiteuren, misschien voorraad; passivarekeningen voor creditcards, leningen, crediteuren; eigen vermogen voor het kapitaal van de eigenaar; inkomstenrekeningen voor verkopen of diensten; en kostenrekeningen voor alle bedrijfsuitgaven. Door dit grootboek bij te houden, kun je op elk moment een winst- en verliesrekening (P&L) en een balans opstellen met behulp van de rapporten of zoekopdrachten van Beancount. Sterker nog, de ingebouwde rapporten van Beancount of Fava kunnen binnen enkele seconden een balans en P&L genereren die perfect in lijn zijn met boekhoudprincipes. Dit kan voldoende zijn voor een kleine onderneming om de winstgevendheid, financiële positie en kasstroom te beoordelen (met een beetje zoeken voor kasstroom, aangezien directe kasstroomoverzichten niet zijn ingebouwd, maar wel kunnen worden afgeleid).
• Facturen en debiteuren, crediteuren: Beancount heeft geen ingebouwd facturatiesysteem; gebruikers zouden de facturatie doorgaans extern afhandelen (bijv. facturen maken in Word of een factuur-app) en vervolgens de resultaten in Beancount vastleggen. Bijvoorbeeld, wanneer je een factuur uitreikt, boek je een post waarbij Debiteuren wordt gedebiteerd en Inkomsten wordt gecrediteerd. Wanneer de betaling binnenkomt, debiteer je Kas/Bank en crediteer je Debiteuren. Op deze manier kun je openstaande vorderingen bijhouden door naar het saldo van de debiteurenrekening te kijken. Hetzelfde geldt voor rekeningen (crediteuren). Hoewel het handmatiger is dan gespecialiseerde boekhoudsoftware (die mogelijk herinneringen stuurt of integreert met e-mails), is het perfect uitvoerbaar. Sommige gebruikers hebben sjablonen of workflows gedeeld over hoe zij facturen beheren met Beancount en ervoor zorgen dat ze geen openstaande facturen missen (bijvoorbeeld door metadata of aangepaste zoekopdrachten te gebruiken om onbetaalde facturen weer te geven).
• Voorraad of Kosten van Verkochte Goederen: Voor bedrijven die producten verkopen, kan Beancount voorraadaankopen en -verkopen bijhouden, maar dit vereist gedisciplineerde boekingen. Je zou de Inventory- en kostprijsboekhoudingsfuncties kunnen gebruiken: het inkopen van voorraad verhoogt een activarekening (met kosten gekoppeld aan de artikelen), het verkopen ervan verplaatst kosten naar een uitgave (KVGG) en registreert omzet. Omdat Beancount aandringt op het matchen van partijen, zal het een correcte afboeking van voorraad met de juiste kosten afdwingen, wat er feitelijk voor kan zorgen dat je brutowinstberekeningen nauwkeurig zijn als het correct wordt gedaan. Er is echter geen geautomatiseerde SKU-tracking of iets dergelijks – het is allemaal op financieel niveau (hoeveelheid en kosten).
• Salarisadministratie en complexe transacties: Beancount kan salarisadministratietransacties vastleggen (salariskosten, belastinginhoudingen, etc.), maar het berekenen van die cijfers kan extern of via een andere tool worden gedaan, en vervolgens gewoon in Beancount worden geboekt. Voor een zeer klein bedrijf (zeg één of twee werknemers) is dit beheersbaar. Je zou bijvoorbeeld per salarisperiode één journaalpost vastleggen die lonen, ingehouden belasting, werkgeversbelastingkosten, betaald contant geld, etc. uitsplitst. Dit handmatig doen is vergelijkbaar met hoe men het in QuickBooks-journaalposten zou doen – het vereist kennis van welke rekeningen moeten worden geraakt.
• Meerdere gebruikers en audit: Een uitdaging in een zakelijke omgeving is wanneer meerdere mensen toegang moeten hebben tot de boeken of wanneer een accountant deze moet controleren. Aangezien Beancount een tekstbestand is, is het niet multi-user in real-time. Het hosten van het bestand in een Git-repository kan echter samenwerking mogelijk maken: elke persoon kan bewerken en committen, en verschillen kunnen worden samengevoegd.
• Wettelijke naleving: Voor belastingaangifte of naleving kunnen de gegevens van Beancount worden gebruikt om de benodigde rapporten te genereren, maar dit kan aangepaste zoekopdrachten of plug-ins vereisen. We zagen een voorbeeld van een community-plug-in voor Indiase overheidsrapportage en één voor FinCEN FBAR-rapportage. Dit toont aan dat Beancount, met inspanning, kan worden aangepast om aan specifieke rapportagevereisten te voldoen. Kleine bedrijven in rechtsgebieden met eenvoudige vereisten (kasboekhouding of basis accrual) kunnen zeker boeken bijhouden in Beancount en financiële overzichten produceren voor belastingaangiften. Echter, functies zoals afschrijvingsschema's of amortisatie vereisen mogelijk dat je je eigen boekingen schrijft of een plug-in gebruikt (de afschrijvingsplug-ins van Dave Stephens helpen dat bijvoorbeeld te automatiseren). Er is geen GUI om op "afschrijven activa" te klikken zoals in sommige boekhoudsoftware; je zou de afschrijving coderen als transacties (wat het op een bepaalde manier demystificeert – alles is een boeking die je kunt inspecteren).

In de praktijk hebben veel technisch georiënteerde eigenaren van kleine bedrijven Beancount (of Ledger/hledger) gebruikt als ze de voorkeur geven aan controle en transparantie boven het gemak van QuickBooks. Een Reddit-discussie merkte op dat voor standaard boekhouding van kleine bedrijven met een beperkt transactievolume, Beancount prima werkt. De beperkende factor is meestal het comfortniveau – of de bedrijfseigenaar (of hun accountant) zich comfortabel voelt met een tekstgebaseerde tool. Een voordeel zijn de kosten: Beancount is gratis, terwijl boekhoudsoftware duur kan zijn voor een klein bedrijf. Aan de andere kant betekent het gebrek aan officiële ondersteuning en het doe-het-zelf-karakter dat het het meest geschikt is voor degenen die zowel de bedrijfseigenaar zijn als enigszins technisch onderlegd. Voor freelancers of eenmanszaken met programmeervaardigheden kan Beancount een aantrekkelijke keuze zijn om financiën te beheren zonder afhankelijk te zijn van cloudboekhoudingsdiensten.

Hybride benaderingen zijn ook mogelijk: sommige kleine bedrijven gebruiken een officieel systeem voor facturen of salarisadministratie, maar importeren de gegevens periodiek in Beancount voor analyse en archivering. Op deze manier krijgen ze het beste van twee werelden – naleving en gemak voor dagelijkse operaties, plus de kracht van Beancount voor geconsolideerd inzicht.

Samenvattend kan Beancount de boekhouding van kleine bedrijven aan, mits de gebruiker bereid is handmatig dingen te beheren die commerciële software automatiseert. Het zorgt voor een hoge mate van transparantie – je begrijpt je boeken diepgaand omdat je ze zelf schrijft – en voor een ijverige gebruiker kan het onberispelijke boeken produceren. Zowel persoonlijke als zakelijke gebruikers profiteren van de kernsterkten van Beancount: een betrouwbare boekhoudmotor, een complete audit trail en flexibiliteit om zich aan te passen aan unieke scenario's (via scripting en plug-ins). Of het nu gaat om het bijhouden van een huishoudbudget of de financiën van een startup, Beancount biedt een toolkit om dit met precisie en openheid te doen.

Gemeenschap en Ontwikkelingsactiviteit​

Beancount heeft een toegewijde gemeenschap en een ontwikkelingsgeschiedenis die de open-source, niche-maar-gepassioneerde aard weerspiegelt. Hieronder staan belangrijke punten over de gemeenschap, beheerders en gerelateerde projecten:

• Projectonderhoud: De primaire auteur van Beancount is Martin Blais, die het project rond 2007 begon en het door meerdere versies heeft geleid. De ontwikkeling was lange tijd grotendeels een eenmansinspanning (afgezien van gemeenschapsbijdragen van patches). Martins filosofie was om een boekhoudtool te bouwen die "eerst nuttig is voor mij, en ook voor anderen, op de eenvoudigste, meest duurzame manier". Deze persoonlijke motivatie hield het project gaande als een liefdeswerk. Vanaf 2025 is Martin Blais nog steeds de hoofdonderhouder (zijn naam verschijnt op commits en hij beantwoordt vragen op de mailinglijst/issue tracker), maar het ecosysteem rond Beancount heeft vele andere bijdragers in hun respectievelijke projecten.

• GitHub en Repositories: De broncode wordt gehost op GitHub onder de beancount/beancount repository. Het project is gelicentieerd onder GPL-2.0 en heeft in de loop der jaren een bescheiden aantal bijdragers aangetrokken. Halverwege 2024 werd Beancount Versie 3 officieel uitgebracht als de nieuwe stabiele tak. Deze release omvatte het opsplitsen van sommige componenten: zo zijn de beangulp repo (voor importeurs) en beanquery repo (voor de querytool) nu onderdeel van de beancount GitHub-organisatie, en worden ze enigszins onafhankelijk onderhouden. De hoofd-Beancount-repo richt zich op de kernboekhoudengine en bestandsparser. Vanaf 2025 toont Beancount's GitHub actieve discussies over issues en enige doorlopende ontwikkeling – hoewel niet met een hoog volume, druppelen issues en pull requests binnen, en worden er af en toe updates uitgevoerd om bugs te verhelpen of functies te verfijnen.

• Fava-ontwikkeling: Fava, de webinterface, begon als een afzonderlijk project (gecreëerd door Dominic Aumayr, die het in 2016 auteursrechtelijk beschermde). Het heeft zijn eigen gemeenschap van bijdragers en staat ook op GitHub onder beancount/fava. Fava's beheerders en bijdragers (bijv. Jakob Schnetz, Stefan Otte en anderen in de afgelopen jaren) hebben de interface actief verbeterd, met releases om de paar maanden. Fava's Gitter-chat (gekoppeld aan de Fava-documentatie) en GitHub issue tracker zijn plaatsen waar gebruikers en ontwikkelaars nieuwe functies of bugs bespreken. Het project verwelkomt bijdragen, wat blijkt uit een CHANGELOG-notitie waarin meerdere gemeenschapsleden worden bedankt voor hun PR's. Fava's nauwe afstemming met de ontwikkeling van Beancount (zoals het snel toevoegen van ondersteuning voor Beancount v3 en nieuwe beanquery-syntaxis) duidt op een goede samenwerking tussen de twee projecten.

• Mailinglijsten en Forums: Beancount heeft een officiële mailinglijst (voorheen op Google Groups, getiteld "Beancount" of soms besproken op de algemene Ledger-lijst). Deze mailinglijst is een schat aan kennis – gebruikers stellen vragen over hoe bepaalde scenario's te modelleren, rapporteren bugs en delen tips. Martin Blais staat erom bekend op de mailinglijst te reageren met gedetailleerde uitleg. Daarnaast is er een grote overlap met de bredere Plain Text Accounting-gemeenschap. De Ledger CLI-mailinglijst behandelt vaak ook vragen over Beancount, en er is een forum op plaintextaccounting.org en een subreddit r/plaintextaccounting waar Beancount-onderwerpen frequent aan bod komen. Gebruikers op deze platforms bespreken vergelijkingen, delen persoonlijke setups en helpen nieuwkomers. De algemene toon van de gemeenschap is zeer coöperatief – Beancount-gebruikers helpen vaak Ledger-gebruikers en vice versa, erkennend dat al deze tools vergelijkbare doelen hebben.

• Chatgroepen: Naast mailinglijsten zijn er chatkanalen zoals de Plaintext Accounting Slack/Discord (door de gemeenschap georganiseerd) en de Fava Gitter. Dit zijn minder formele, meer real-time manieren om hulp te krijgen of functies te bespreken. Men kan bijvoorbeeld op Slack springen om te vragen of iemand een importeur heeft voor een specifieke bank. Er is ook een Matrix/IRC-kanaal (historisch #ledger of #beancount op IRC) waar sommige langdurige gebruikers aanwezig zijn. Hoewel niet zo populair als gemeenschappen voor mainstream software, hebben deze kanalen deskundige mensen die vaak antwoord kunnen geven op obscure boekhoudvragen.

• Bijdragers en Belangrijke Gemeenschapsleden: Enkele namen vallen op in de Beancount-gemeenschap:

  • "Redstreet" (Red S): Een productieve bijdrager die veel plugins heeft geschreven (zoals beancount-balexpr, sellgains en andere) en vaak ondersteuning biedt. Zij onderhouden ook een set importeursscripts en een tool genaamd bean-download om afschriften op te halen.
  • Vasily M (Evernight): Auteur van enkele importeurframeworks en plugins zoals beancount-valuation, en bijdragen aan Fava met betrekking tot investeringen.
  • Stefano Zacchiroli (zack): Een Debian-ontwikkelaar die de beancount-mode voor Emacs en zijn eigen plugin-repo heeft gemaakt. Hij heeft ook gepleit voor plaintext accounting in academische settings.
  • Simon Michael: Hoewel hij voornamelijk de leider is van hledger, beheert hij plaintextaccounting.org, dat Beancount omvat. Deze kruisbestuiving heeft geholpen Beancount onder de aandacht te brengen van Ledger/hledger-gebruikers.
  • Frank hell (Tarioch): Bijdrager van de Tarioch Beancount Tools, een belangrijke set importeurs en prijsophalers, vooral voor Europese instellingen.
  • Siddhant Goel: Een gemeenschapslid dat blogt over Beancount (bijvoorbeeld zijn gids over migreren naar v3) en enkele importeurs onderhoudt. Zijn blogposts hebben veel nieuwe gebruikers geholpen.

  Deze en vele anderen dragen code, documentatie en hulp bij op forums, waardoor het ecosysteem levendig blijft ondanks de relatief kleine omvang.

• GitHub Statistieken en Forks: Beancount's GitHub-repo heeft enkele honderden sterren (wat interesse aangeeft) en forks verzameld. Opvallende forks van Beancount zelf zijn zeldzaam – er is geen bekende afwijkende fork die probeert "Beancount maar met functie X" te zijn. In plaats daarvan, wanneer gebruikers iets anders wilden, schreven ze ofwel een plugin of gebruikten ze een andere tool (zoals hledger) in plaats van Beancount te forken. Men zou hledger kunnen beschouwen als een soort fork van Ledger (niet Beancount) en Beancount zelf als een onafhankelijke herinterpretatie van Ledgers ideeën, maar binnen Beancount's repo zijn er geen grote afsplitsingsprojecten. De gemeenschap heeft zich over het algemeen verenigd rond de hoofd-repo en deze uitgebreid via de plugin-interface in plaats van de codebase te fragmenteren. Dit komt waarschijnlijk doordat Martin Blais openstond voor externe bijdragen (zijn documentatie heeft zelfs een sectie die externe bijdragen en modules erkent) en de plugin-architectuur het onnodig maakte om een fork te onderhouden voor de meeste nieuwe functies.

• Gemeenschapsbronnen: Er zijn verschillende hoogwaardige bronnen voor het leren en gebruiken van Beancount, gecreëerd door de gemeenschap:

  • De Beancount-documentatie op GitHub Pages (en de bron Google Docs die Martin onderhoudt) – zeer uitgebreid, inclusief theorie over boekhouding en hoe Beancount dit implementeert.

  • Talrijke blogposts en persoonlijke notities – bijv. LWN.net had een artikel "Counting beans… with Beancount", en veel persoonlijke blogs (zoals vermeld in de sectie "Blog Posts" van Awesome Beancount) delen ervaringen en tips. Deze helpen kennis op te bouwen en nieuwe gebruikers aan te trekken.

  • Lezingen en presentaties: Beancount is gepresenteerd op meetups en conferenties (bijvoorbeeld een PyMunich 2018-lezing over het beheren van financiën met Python

Recente Ontwikkelingen en Aankomende Functies​

Vanaf 2025 heeft het Beancount-ecosysteem de afgelopen paar jaar aanzienlijke ontwikkelingen doorgemaakt, en er zijn voortdurende discussies over toekomstige verbeteringen. Hier zijn enkele opmerkelijke recente ontwikkelingen en een vooruitblik op wat er mogelijk komen gaat:

• Beancount 3.0 Release (2024): Na een lange periode waarin Beancount 2.x de standaard was, werd versie 3 medio 2024 officieel uitgebracht. Dit was een belangrijke mijlpaal omdat v3 een vereenvoudiging en modernisering van de codebase vertegenwoordigt. Martin Blais had v3 voor ogen als een kans om het systeem verder te “herschikken en vereenvoudigen”. Hoewel oorspronkelijk werd gedacht dat het een grote herschrijving zou zijn, was de update voor gebruikers in de praktijk niet al te storend. De belangrijkste wijzigingen waren onder de motorkap: een nieuwe parser, enkele prestatieverbeteringen en de extractie van optionele componenten uit de kern. De release werd geleidelijk uitgerold (v3 was sinds 2022 in bèta, maar in juli 2024 werd het de aanbevolen stabiele versie). Gebruikers zoals Siddhant Goel meldden dat de migratie van 2.x naar 3.x “meestal zonder problemen” verliep, met slechts enkele wijzigingen in de workflow.

• Modularisatie – tools verplaatst naar afzonderlijke pakketten: Een van de grote veranderingen met Beancount 3 is dat veel tools die voorheen in de monolithische repository zaten, zijn afgesplitst. Zo wordt bean-query nu geleverd door het beanquery-pakket, en beancount.ingest is vervangen door het beangulp-pakket. Commando's zoals bean-extract en bean-identify (voor imports) zijn verwijderd uit de kern van Beancount. In plaats daarvan is de filosofie om standalone scripts te gebruiken voor importeren. Dit betekent dat als je upgrade naar v3, je beangulp installeert en importer-scripts uitvoert (elke importer is in feite een klein programma) in plaats van een centraal bean-extract configuratiebestand te hebben. Op dezelfde manier worden queries uitgevoerd via beanquery, dat onafhankelijk van de Beancount-kern kan worden geïnstalleerd en bijgewerkt. Deze modulaire aanpak is ontworpen om onderhoud te vergemakkelijken en bijdragen van de gemeenschap aan te moedigen. Het heeft ook de kern van Beancount afgeslankt, zodat de kern zich puur richt op parsing en boekhoudkundige logica, terwijl aanvullende functionaliteit afzonderlijk kan evolueren. Vanuit gebruikersperspectief moet men na het upgraden commando's aanpassen (bijv. bean-query gebruiken van beanquery, of Fava gebruiken dat dit sowieso abstraheert). Fava's changelog vermeldt deze wijzigingen expliciet: Fava is nu afhankelijk van beanquery en beangulp, en het behandelt importworkflows anders voor Beancount 3 versus 2.

• Prestatieverbeteringen: Prestaties waren een motivatie om het ontwerp van Beancount opnieuw te bekijken. Het v3-plan (zoals uiteengezet in Martins “V3 goals” document) omvatte het optimaliseren van de parser en mogelijk het sneller en minder geheugenintensief maken van het laadproces. Tegen 2025 zijn sommige van deze verbeteringen gerealiseerd. Anekdotisch hebben gebruikers met zeer grote grootboeken (tienduizenden transacties, of veel aandelenhandel) betere prestaties gemeld met de nieuwste versie. Een gebruiker die te maken had met “micro-investeringstransacties” en prestatieproblemen ondervond, merkte deze zorgen bijvoorbeeld op in de Google Group – dit soort feedback heeft waarschijnlijk v3 geïnformeerd. De nieuwe parser is efficiënter en duidelijker geschreven, wat in de toekomst kan worden uitgebreid. Bovendien is Fava 1.29 overgestapt op een efficiënter bestandsbewakingsmechanisme (met behulp van de watchfiles-bibliotheek) om de responsiviteit te verbeteren wanneer het grootboek verandert. Vooruitkijkend zou de gemeenschap incrementele parsing kunnen onderzoeken (alleen gewijzigde delen van het bestand opnieuw verwerken in plaats van alles) om grote grootboeken sneller te verwerken – dit werd in de documentatie gesuggereerd als het idee van een “Beancount server / incrementele boeking”.

• **Verbeteringen in Investering

Hallo iedereen! In de blogpost van vandaag duiken we in de wereld van Beancount, een tool voor dubbel boekhouden die door velen geliefd is om zijn eenvoud en kracht. Meer specifiek gaan we het hebben over twee belangrijke concepten: Vorderingen en Schulden.

Het begrijpen van deze termen is cruciaal om Beancount (of elk ander systeem voor dubbel boekhouden) effectief te gebruiken. Maar maak je geen zorgen als je een beginner bent - we gaan alles stap voor stap uitleggen!

Vorderingen en Schulden: De Basis​

In de boekhouding zijn "vorderingen" en "schulden" termen die worden gebruikt om geld te volgen dat verschuldigd is. "Vorderingen" verwijst naar geld dat anderen jou verschuldigd zijn, terwijl "schulden" verwijst naar geld dat jij aan anderen verschuldigd bent.

Laten we een voorbeeld nemen:

1. Debiteuren (A/R): Stel, je hebt een boekhandel en een klant koopt een boek op krediet. Het geld dat zij jou verschuldigd zijn voor het boek, is een debiteurenpost.

2. Crediteuren (A/P): Aan de andere kant, stel je bestelt een nieuwe set boeken bij een uitgever, maar je betaalt deze niet direct. Het geld dat jij de uitgever verschuldigd bent, is een crediteurenpost.

In Beancount worden deze doorgaans bijgehouden via corresponderende rekeningen. Het belangrijkste voordeel hiervan is dat het je op elk moment een duidelijk en nauwkeurig beeld geeft van je financiële positie.

Vorderingen en Schulden instellen in Beancount​

De structuur van je Beancount-bestand kan zo eenvoudig of complex zijn als je zelf wilt. Voor vorderingen en schulden wil je waarschijnlijk aparte rekeningen aanmaken onder je Activa- en Passiva-secties.

Hier is een eenvoudig voorbeeld:

1970-01-01 open Assets:AccountsReceivable
1970-01-01 open Liabilities:AccountsPayable

Transacties bijhouden​

Debiteurenzijde​

Nadat je je rekeningen hebt ingesteld, kun je transacties bijhouden die vorderingen en schulden betreffen. Laten we een voorbeeld bekijken:

2023-05-29 * "Sold books to customer on credit"
  Assets:AccountsReceivable  100 USD
  Income:BookSales          -100 USD

Hier voeg je $100 toe aan je vorderingen omdat een klant je dit bedrag verschuldigd is. Tegelijkertijd verminder je je inkomsten met hetzelfde bedrag om de balans te behouden (aangezien je het geld nog niet daadwerkelijk hebt ontvangen).

Wanneer de klant uiteindelijk betaalt, leg je dit als volgt vast:

2023-06-01 * "Received payment from customer"
  Assets:Bank:Savings        100 USD
  Assets:AccountsReceivable -100 USD

Crediteurenzijde​

Hetzelfde principe geldt voor schulden, maar met omgekeerde tekens:

2023-05-30 * "Bought books from publisher on credit"
  Liabilities:AccountsPayable  200 USD
  Expenses:BookPurchases     -200 USD

En wanneer je je schuld aflost:

2023-06-02 * "Paid off debt to publisher"
  Liabilities:AccountsPayable -200 USD
  Assets:Bank:Checking        200 USD

Samenvatting​

Vorderingen en schulden vormen de kern van elk boekhoudsysteem. Door deze nauwkeurig bij te houden, krijg je een uitgebreid inzicht in je financiële gezondheid.

Dit is slechts een startpunt, en Beancount is tot veel meer in staat. Ik hoop dat deze blogpost helpt om deze belangrijke concepten te verduidelijken. Zoals altijd, veel plezier met boekhouden!

In de blogpost van vandaag zullen we een Beancount grootboek voor bedrijven ontleden, wat u zal helpen de fijne kneepjes van dit platte tekst dubbel boekhoudsysteem te begrijpen.

Laten we beginnen met de code:

1970-01-01 open Assets:Bank:Mercury
1970-01-01 open Assets:Crypto

1970-01-01 open Equity:Bank:Chase

1970-01-01 open Income:Stripe
1970-01-01 open Income:Crypto:ETH

1970-01-01 open Expenses:COGS
1970-01-01 open Expenses:COGS:Contabo
1970-01-01 open Expenses:COGS:AmazonWebServices

1970-01-01 open Expenses:BusinessExpenses
1970-01-01 open Expenses:BusinessExpenses:ChatGPT

2023-05-14 * "CONTABO.COM" "Mercury Checking ••1234"
  Expenses:COGS:Contabo                               17.49 USD
  Assets:Bank:Mercury                                -17.49 USD

2023-05-11 * "Amazon Web Services" "Mercury Checking ••1234"
  Expenses:COGS:AmazonWebServices                  14490.33 USD
  Assets:Bank:Mercury                             -14490.33 USD

2023-03-01 * "STRIPE" "Mercury Checking ••1234"
  Income:Stripe                                   -21230.75 USD
  Assets:Bank:Mercury                              21230.75 USD

2023-05-18 * "customer_182734" "0x5190E84918FD67706A9DFDb337d5744dF4EE5f3f"
  Assets:Crypto                                         -19 ETH {1,856.20 USD}
  Income:Crypto:ETH                                      19 ETH @@ 35267.8 USD

De Code Begrijpen​

1. Rekeningen Openen: De code begint met het openen van een reeks rekeningen op 1970-01-01. Deze omvatten een mix van activarekeningen (Assets:Bank:Mercury en Assets:Crypto), een eigen vermogen rekening (Equity:Bank:Chase), inkomstenrekeningen (Income:Stripe en Income:Crypto:ETH), en kostenrekeningen (Expenses:COGS, Expenses:COGS:AmazonWebServices, Expenses:BusinessExpenses, en Expenses:BusinessExpenses:ChatGPT).

2. Transacties: Vervolgens worden een reeks transacties geregistreerd tussen 2023-03-01 en 2023-05-18.

   • De transactie op 2023-05-14 vertegenwoordigt een betaling van $17,49 aan CONTABO.COM vanaf Mercury Checking ••1234. Dit wordt geregistreerd als een uitgave (Expenses:COGS:Contabo) en een overeenkomstige afschrijving van de rekening Assets:Bank:Mercury.

   • Op vergelijkbare wijze vertegenwoordigt de transactie op 2023-05-11 een betaling van $14490,33 aan Amazon Web Services vanaf dezelfde bankrekening. Dit wordt geregistreerd onder Expenses:COGS:AmazonWebServices.

   • De transactie op 2023-03-01 toont inkomsten van STRIPE die worden gestort op Mercury Checking ••1234, in totaal $21230,75. Dit wordt geregistreerd als inkomsten (Income:Stripe) en een toevoeging aan de bankrekening (Assets:Bank:Mercury).

   • De laatste transactie op 2023-05-18 vertegenwoordigt een cryptotransactie van 19 ETH van een klant. Dit wordt bijgehouden onder Assets:Crypto en Income:Crypto:ETH. De {1.856,20 USD} toont de prijs van ETH op het moment van de transactie, terwijl de @@ 35.267,8 USD de totale waarde van de 19 ETH-transactie specificeert.

Bij alle transacties wordt het principe van dubbel boekhouden gehandhaafd, wat ervoor zorgt dat de vergelijking Activa = Passiva + Eigen Vermogen altijd klopt.

Slotgedachten​

Dit Beancount grootboek biedt een eenvoudig doch robuust systeem voor het bijhouden van financiële transacties. Zoals te zien is in de laatste transactie, is Beancount flexibel genoeg om rekening te houden met niet-traditionele activa zoals cryptocurrency, wat een bewijs is van de bruikbaarheid ervan in ons steeds digitaler wordende financiële landschap.

We hopen dat deze uiteenzetting u helpt de structuur en mogelijkheden van Beancount beter te begrijpen, of u nu een ervaren accountant bent of een beginner die zijn persoonlijke financiën probeert bij te houden. Blijf op de hoogte voor onze volgende blogpost, waarin we dieper ingaan op geavanceerde Beancount-bewerkingen.

Voorbeeld Rekeningnaam​

Assets:US:BofA:Checking

Rekeningtypen​

Assets          +
Liabilities     -
Income          -
Expenses        +
Equity          -

Goederen​

CNY, EUR, CAD, AUD
GOOG, AAPL, RBF1005
HOME_MAYST, AIRMILES
HOURS

Directieven​

Algemene syntaxis

JJJJ-MM-DD <Directief> <Parameters...>

Rekeningen Openen & Sluiten​

2001-05-29 open Expenses:Restaurant
2001-05-29 open Assets:Checking     USD,EUR  ; Valutabeperkingen

2015-04-23 close Assets:Checking

Goederen Declaren (Optioneel)​

1998-07-22 commodity AAPL
  name: "Apple Computer Inc."

Prijzen​

2015-04-30 price AAPL   125.15 CNY
2015-05-30 price AAPL   130.28 CNY

Notities​

2013-03-20 note Assets:Checking "Gebeld om te vragen naar korting"

Documenten​

2013-03-20 document Assets:Checking "pad/naar/afschrift.pdf"

Transacties​

2015-05-30 * "Enige omschrijving van deze transactie"
  Liabilities:CreditCard   -101.23 CNY
  Expenses:Restaurant       101.23 CNY

2015-05-30 ! "Kabelbedrijf" "Telefoonrekening" #tag ˆlink
  id: "TW378743437"               ; Metadata
  Expenses:Home:Phone  87.45 CNY
  Assets:Checking                 ; U mag één bedrag weglaten

Boekingen​

  ...    123.45 USD                             Eenvoudig
  ...        10 GOOG {502.12 USD}               Met kosten per eenheid
  ...        10 GOOG {{5021.20 USD}}            Met totale kosten
  ...        10 GOOG {502.12 # 9.95 USD}        Met beide kosten
  ...   1000.00 USD   @ 1.10 CAD                Met prijs per eenheid
  ...        10 GOOG {502.12 USD} @ 1.10 CAD    Met kosten & prijs
  ...        10 GOOG {502.12 USD, 2014-05-12}   Met datum
  ! ...   123.45 USD ...                        Met vlag

Saldo-asserties en Opvulling​

; Bevestigt het bedrag alleen voor de opgegeven valuta:
2015-06-01 balance Liabilities:CreditCard  -634.30 CNY

; Automatische invoeging van transactie om aan de volgende assertie te voldoen:
2015-06-01pad Assets:Checking Equity:Opening-Balances

Gebeurtenissen​

2015-06-01 event "locatie" "New York, VS"
2015-06-30 event "adres" "May Street 123"

Opties​

option "title" "Mijn Persoonlijke Grootboek"

Overig​

pushtag #reis-naar-peru
...
poptag  #reis-naar-peru
; Opmerkingen beginnen met een puntkomma

Ontdek de Magie van Plain Text Boekhouden met Beancount

Introductie​

Welkom in een wereld waar boekhouden geen ontmoedigende taak meer is. Vandaag introduceren we u Beancount, een krachtige, flexibele en intuïtieve plain text boekhoudtool. Beancount stelt u in staat om controle te krijgen over uw financiën door een transparante en eenvoudige benadering te bieden voor het beheren van uw geld.

In deze uitgebreide gids duiken we in de basisprincipes van Beancount, leggen we de kernconcepten uit en leiden we u door de eenvoudige doch krachtige functies. Aan het einde van deze blog heeft u een gedegen begrip van Beancount en bent u klaar om het te gebruiken om uw financiële leven te organiseren en te analyseren.

Wat is Beancount?​

Beancount is een open-source, plain text boekhoudsysteem, gecreëerd door Martin Blais. Geïnspireerd door John Wiegley's Ledger-systeem, streeft Beancount ernaar een robuuste en betrouwbare methode te bieden voor het beheren van persoonlijke en kleine bedrijfsfinanciën met behulp van plain text bestanden. Met Beancount kunt u eenvoudig uw inkomsten, uitgaven, investeringen en nog veel meer bijhouden.

Waarom Beancount?​

Plain text boekhouden biedt verschillende voordelen ten opzichte van traditionele spreadsheet-gebaseerde of software-gebaseerde boekhoudsystemen:

• Transparantie: Beancount-bestanden zijn menselijk leesbaar, waardoor het eenvoudig is om uw financiële gegevens te begrijpen en te controleren.
• Flexibiliteit: Beancount kan eenvoudig worden aangepast aan uw specifieke behoeften, en u kunt uw favoriete teksteditor en versiebeheersysteem gebruiken om uw financiële gegevens te beheren.
• Portabiliteit: Uw financiële gegevens zijn toegankelijk op elk apparaat, en het is eenvoudig om ze over te dragen tussen systemen of te delen met anderen.
• Toekomstbestendig: Plain text bestanden zijn universeel compatibel, wat garandeert dat uw financiële gegevens toegankelijk blijven, zelfs naarmate technologie evolueert.

Kernconcepten van Beancount​

Om Beancount effectief te gebruiken, is het cruciaal om de kernconcepten te begrijpen:

• Transacties: Financiële gebeurtenissen, zoals inkomsten, uitgaven of overboekingen tussen rekeningen, worden vastgelegd als transacties.
• Rekeningen: Transacties omvatten één of meer rekeningen, zoals activa, passiva, inkomsten of uitgaven.
• Dubbele boekhouding: Beancount handhaaft dubbele boekhouding, wat garandeert dat elke transactie gebalanceerde debets en credits heeft.
• Directieven: Beancount gebruikt een set directieven om transacties, rekeningopeningen en andere financiële gebeurtenissen te definiëren.

Aan de slag met Beancount​

Volg deze eenvoudige stappen om Beancount te gaan gebruiken:

• Installeer Beancount: Installeer Beancount op uw systeem met behulp van de meegeleverde installatie-instructies voor uw besturingssysteem.
• Maak uw Beancount-bestand: Maak een nieuw plain text bestand met de .beancount extensie (bijv. mijn_financiën.beancount).
• Definieer uw rekeningen: Gebruik de "open" directive om de rekeningen te definiëren die u in uw transacties zult gebruiken.
• Registreer transacties: Gebruik de "txn" directive om uw financiële transacties vast te leggen.

Of meld u eenvoudig aan op https://beancount.io. Hier zijn enkele plain text boekhoudvoorbeelden -

Voorbeeld 1: Basis Transactie

2023-04-01 open Assets:Checking
2023-04-01 open Expenses:Groceries

2023-04-10 txn "Grocery Store" "Buying groceries"
  Assets:Checking         -50.00 USD
  Expenses:Groceries       50.00 USD

In dit voorbeeld openen we twee rekeningen, Activa:Betaalrekening en Uitgaven:Boodschappen. Op 10 april 2023 registreren we een transactie voor het kopen van boodschappen ter waarde van $50. De transactie vermindert het saldo van Activa:Betaalrekening met $50 (debet) en verhoogt het saldo van Uitgaven:Boodschappen met $50 (credit).

Voorbeeld 2: Inkomsten- en Uitgavetransactie

2023-04-01 open Assets:Checking
2023-04-01 open Income:Salary
2023-04-01 open Expenses:Rent

2023-04-05 txn "Employer" "Salary payment"
  Assets:Checking       2000.00 USD
  Income:Salary        -2000.00 USD

2023-04-06 txn "Landlord" "Monthly rent payment"
  Assets:Checking       -1000.00 USD
  Expenses:Rent          1000.00 USD

In dit voorbeeld openen we drie rekeningen: Activa:Betaalrekening, Inkomsten:Salaris en Uitgaven:Huur. Op 5 april 2023 registreren we een salarisbetalingstransactie van $2000. De transactie verhoogt het saldo van Activa:Betaalrekening met $2000 (credit) en verlaagt het saldo van Inkomsten:Salaris met $2000 (debet). Op 6 april 2023 registreren we een huurbetalingstransactie van $1000. De transactie vermindert het saldo van Activa:Betaalrekening met $1000 (debet) en verhoogt het saldo van Uitgaven:Huur met $1000 (credit).

Voorbeeld 3: Overboeking Tussen Rekeningen

2023-04-01 open Assets:Checking
2023-04-01 open Assets:Savings

2023-04-15 txn "Bank" "Transfer from Checking to Savings"
  Assets:Checking       -500.00 USD
  Assets:Savings         500.00 USD

In dit voorbeeld openen we twee rekeningen: Activa:Betaalrekening en Activa:Spaarrekening. Op 15 april 2023 registreren we een transactie om $500 over te boeken van de betaalrekening naar de spaarrekening. De transactie vermindert het saldo van Activa:Betaalrekening met $500 (debet) en verhoogt het saldo van Activa:Spaarrekening met $500 (credit).

Deze voorbeelden illustreren de basisconcepten van Beancount's dubbele boekhoudsysteem. Door transacties correct vast te leggen, kunnen gebruikers nauwkeurige overzichten van hun financiële activiteiten bijhouden en rapporten genereren om inzicht te krijgen in hun financiële situatie.

Rapporten Genereren en Gegevens Analyseren​

Beancount wordt geleverd met een reeks krachtige tools voor het genereren van financiële rapporten, waaronder balansen, winst- en verliesrekeningen en meer. U kunt ook Fava gebruiken, een webgebaseerde gebruikersinterface voor Beancount, om uw financiële gegevens te visualiseren en ermee te interacteren. https://beancount.io is gebouwd op Fava met MIT-licentie.

Conclusie​

Omarm de kracht en eenvoud van plain text boekhouden met Beancount. Door de kernconcepten te begrijpen en de stappen in deze gids te volgen, bent u goed op weg om uw persoonlijke of kleine bedrijfsfinanciën met gemak en precisie te beheren. Naarmate u meer vertrouwd raakt met Beancount, kunt u geavanceerde functies en aanpassingen verkennen om het systeem af te stemmen op uw unieke behoeften.

Of u nu uw uitgaven wilt bijhouden, wilt plannen voor de toekomst, of inzicht wilt krijgen in uw financiële gewoonten, Beancount biedt de flexibiliteit en transparantie die nodig zijn om uw doelen te bereiken. Met zijn gebruiksvriendelijke benadering heeft Beancount het potentieel om de manier waarop u uw financiën beheert te revolutioneren en u in staat te stellen de controle over uw financiële toekomst te nemen.

Nu u een solide basis in Beancount heeft, is het tijd om aan uw plain text boekhoudreis te beginnen. Zeg vaarwel tegen omslachtige spreadsheets en ingewikkelde software, en verwelkom de wereld van Beancount. Veel plezier met boekhouden!

Waarom Moderne Boekhouding Belangrijk Is​

Nog steeds uw beleggingen beheren met spreadsheets? Hoewel spreadsheets veelzijdig zijn, kunnen ze omslachtig en foutgevoelig worden naarmate uw beleggingsportefeuille groeit. Maak kennis met Beancount.io – een geavanceerd doch gebruiksvriendelijk platform voor het bijhouden van beleggingen, speciaal ontworpen voor het beheren van aandelen- en cryptocurrency-portefeuilles. Beancount.io is ontwikkeld met ingenieurs en financiële minimalisten in gedachten en combineert krachtige functies met een intuïtieve interface om uw beleggingstracking-ervaring te stroomlijnen.

Dubbel Boekhouden: De Basis van Nauwkeurigheid​

Beancount.io is gebouwd op de principes van dubbel boekhouden – een beproefde methodologie die wereldwijd door financiële instellingen wordt gebruikt. Dit systeem garandeert wiskundige nauwkeurigheid door middel van een eenvoudig doch krachtig concept: elke financiële transactie moet perfect in balans zijn.

Bij dubbel boekhouden vereist elke transactie ten minste twee boekingen – een debet (+) en een credit (-) – over verschillende rekeningen. Dit ingebouwde verificatiesysteem maakt het vrijwel onmogelijk om onbalans-transacties vast te leggen, waardoor uw financiële gegevens nauwkeurig en betrouwbaar blijven.

1970-01-01 open Income:BeancountCorp
1970-01-01 open Assets:Cash
1970-01-01 open Expenses:Food
1970-01-01 open Assets:Receivables:Alice
1970-01-01 open Assets:Receivables:Bob
1970-01-01 open Assets:Receivables:Charlie
1970-01-01 open Liabilities:CreditCard

2019-05-31 * "BeancountCorp" "Salary of May 15th to May 31st"
  Income:BeancountCorp               -888 USD
  Assets:Cash                         888 USD

2019-07-12 * "Popeyes chicken sandwiches" "dinner with Alice, Bob, and Charlie"
  Expenses:Food 20 USD
  Assets:Receivables:Alice 20 USD
  Assets:Receivables:Bob 20 USD
  Assets:Receivables:Charlie 20 USD
  Liabilities:CreditCard -80 USD

Zoals u in de twee voorbeelden hierboven kunt zien, moet elke transactie voldoen aan de boekhoudkundige vergelijking.

Activa = Passiva + Eigen Vermogen (ook wel Netto Activa)

We hebben de Beancount-syntaxis van Martin Blais en het webproject Fava van Jakob Schnitzer gebruikt om deze website te bouwen. En het zal u waarschuwen als een transactie posten heeft die niet op nul uitkomen.

Nu begrijpt u hoe we de correctheid van het grootboek afdwingen. Maar u vraagt zich misschien af wat die "rekeningen" zijn?

Rekeningen Begrijpen: De Wateremmer Analogie​

Stel u uw financiële rekeningen voor als een systeem van onderling verbonden wateremmers, waar geld als water tussen stroomt. Deze analogie maakt dubbel boekhouden intuïtief: wanneer u geld van de ene rekening naar de andere overboekt, is het alsof u water van de ene emmer naar de andere giet – de totale hoeveelheid water (geld) in het systeem blijft constant.

Beancount.io introduceert vijf soorten rekeningen.

1. Inkomsten — Het bedrag is altijd negatief of in debet. Dit komt omdat u geld verdient, en het geld dan wordt gedebiteerd van de "Inkomsten"-rekening en gecrediteerd naar uw "Activa."
2. Uitgaven — Het bedrag is altijd positief of in credit. Dit komt omdat u geld uitgeeft, en het geld stroomt van de "Activa" of "Passiva" naar de "Uitgaven."
3. Passiva — Het bedrag is positief of nul. Uw creditcardverplichtingen zijn een goed voorbeeld, die in cycli stijgen en dalen.
4. Activa — Het bedrag is positief of nul. Uw contant geld of huizen zijn altijd een bepaalde prijs waard.
5. Eigen Vermogen — Uw netto activa. Het systeem berekent dit automatisch voor u. Eigen Vermogen = Activa - Passiva en het weerspiegelt hoe vermogend u bent.

Nu kunt u uw aangepaste rekeningen openen met de bovenstaande trefwoorden:

1970-01-01 open Assets:Cash
1970-01-01 open Assets:Stock:Robinhood
1970-01-01 open Assets:Crypto:Coinbase
1970-01-01 open Expenses:Transportation:Taxi
1970-01-01 open Equity:OpeningBalance

Geavanceerde Beleggingstracking met Activa​

Beancount.io blinkt uit in het bijhouden van diverse beleggingen, van aandelen tot cryptocurrencies. Laten we eens kijken hoe het omgaat met complexe beleggingsscenario's. Hier is bijvoorbeeld hoe u de aankoop van 10 Bitcoins voor $100 per stuk in 2014 zou vastleggen:

2014-08-08 * "Buy 10 Bitcoin"
  Assets:Trade:Cash -1000.00 USD
  Assets:Trade:Positions  10 BTC {100.00 USD}

En dan, drie jaar later, verkoopt u ze (oorspronkelijk met kosten van $100 per eenheid, geannoteerd met {100.00 USD}) tegen een prijs van $10.000 per eenheid, geannoteerd met @ 10,000.00 USD.

2017-12-12 * "Sell 2 Bitcoin"
  Assets:Trade:Positions                   -2 BTC {100.00 USD} @ 10,000.00 USD
  Assets:Trade:Cash                          20,000.00 USD
  Income:Trade:PnL                          -19,800.00 USD

Of dezelfde transactie met @@ 20,000.00 USD betekent dat tegen een prijs van $20.000 in totaal.

2017-12-12 * "Sell 2 Bitcoin"
  Assets:Trade:Positions                   -2 BTC {100.00 USD} @@ 20,000.00 USD
  Assets:Trade:Cash                          20,000.00 USD
  Income:Trade:PnL                          -19,800.00 USD

De som van alle posten van de transactie, inclusief -2 BTC {100.00 USD}, is nog steeds, zoals altijd, nul.

De kosten {100.00 USD} tag is belangrijk omdat u dezelfde activa tegen verschillende kosten gekocht kunt hebben.

100 BTC {10.00 USD, 2012-08-08}
10 BTC {100.00 USD, 2014-08-08}

Als u het proces wilt vereenvoudigen, kunt u de rekening aan het begin instellen met FIFO of LIFO. FIFO staat voor 'first in, first out' (eerst in, eerst uit), terwijl LIFO staat voor 'last in, first out' (laatst in, eerst uit). In de VS gebruikt de IRS FIFO om uw winst en verlies (W&V) en bijbehorende belasting te berekenen.

1970-01-01 open Assets:Trade:Positions "FIFO"

En wanneer u het dan in verkorte vorm verkoopt, zoals -2 BTC {}, zal Beancount automatisch de FIFO-strategie toepassen en de oudste activa verkopen.

Aan de Slag met Beancount.io​

Beancount.io is een modern, cloud-gebaseerd financieel managementplatform dat uw tekstgebaseerde transactiegegevens omzet in uitgebreide financiële overzichten, waaronder winst- en verliesrekeningen, balansen en proefbalansen. Door de betrouwbaarheid van platte tekstbestanden te combineren met krachtige visualisatietools, helpt Beancount.io u nauwkeurige controle te behouden over uw financiële leven, terwijl u waardevolle inzichten krijgt in uw beleggingsprestaties.

Begin uw financiële reis met Beancount.io - Gratis tijdens onze promotieperiode!