Beancount ou la comptabilité pour les hackers

En matière de comptabilité personnelle, l’offre en logiciels et autres applications pour smartphones ne manque pas, et pourtant après de nombreuses tentatives je n’ai rien trouvé qui me convenait: les solutions existantes étaient toujours ou trop simplistes ou trop complexes, trop chères, pas assez ergonomiques, trop instables, et j’en passe…

Sur le point de développer ma propre application, j’ai finalement découvert Beancount, qui s’approche de la perfection, en tout cas pour mes besoins. Je vais donc présenter dans cet article le principe de Beancount, et comment l’utiliser pour gérer ses comptes.

Beancount est basé sur la comptabilité en partie double, et repose sur l’enregistrement des transactions dans un simple fichier texte: il est donc possible de tout faire en ligne de commande, ce qui ravira les fans de Linux, et fera certainement fuir les autres utilisateurs habitués aux interfaces graphiques ;) . Beancount fournit entre autres une interface Web pour explorer ses comptes, un langage de requêtes similaire à SQL,  et permet d’écrire ses propres plugins et scripts en Python pour étendre les fonctionnalités.

La comptabilité en partie double

Avant de comprendre Beancount, il faut d’abord maîtriser les bases de la comptabilité en partie double. Il s’agit de la méthode utilisée pour effectuer la comptabilité d’une entreprise, d’une organisation, ou d’un État dans les règles de l’art, mais on peut très bien l’appliquer pour gérer ses comptes personnels.

Son principe est assez simple: toute transaction (achat, vente, virement, etc.) est représentée par un transfert d’argent entre deux (ou plus) comptes. La notion de compte est ici à prendre au sens large: il peut s’agir d’un compte bancaire, d’un compte de caisse, mais aussi d’un poste de dépenses, d’un compte représentant des stocks, etc.

La règle absolue à respecter dans la comptabilité en partie double est que tout sortie d’argent doit être compensée par une rentrée équivalente (et vice-versa). Par exemple, supposons que vous achetez un lot de ramettes de papier pour 50 euros: votre compte bancaire sera donc diminué de 50 euros, et en contrepartie il faut augmenter votre compte “Fournitures de bureau” de 50 euros. De même, si vous recevez un salaire de 2000 euros, vous augmentez votre compte bancaire de 2000 euros, et en contrepartie vous devez donc diminuer votre compte “Salaires” du même montant.

A ce stade, voici comment on peut enregistrer ces opérations en comptabilité:

Grâce au principe de partie double, c’est-à-dire l’écriture de toute transaction dans deux comptes simultanément, la somme de toutes les opérations est toujours nulle, ce qui permet de s’assurer facilement qu’il n’y a pas d’erreur dans les comptes.

Il peut sembler peu intuitif que le compte “Salaire” soit négatif, puisque c’est de l’argent gagné, mais il suffit de se souvenir que les comptes doivent s’équilibrer, donc si le compte “Banque” augmente, le compte “Salaire” doit diminuer. Une autre façon de voir les choses est de considérer l’argent du salaire comme la contepartie d’un travail: le salarié reçoit de l’argent sur son compte en banque en échange du travail qu’il donne à son employeur. Puisque le travail est donné, c’est donc quelque chose qui “sort”, et par conséquent il doit être comptabilisé en négatif.

Après avoir enregistré toutes les opérations, on peut calculer le solde de chaque compte, en additionant tous les montants affectés à ces comptes depuis leur ouverture:

Si vous avez compris les explications précédentes, il doit être clair que la somme des soldes de tous les comptes doit être égale à 0, ce qui est une bonne façon de vérifier qu’il n’y a pas d’erreurs.

Actif, Passif, Dépenses et Recettes

Pour organiser la comptabilité, les différents comptes sont répartis en quatre catégories: actif, passif, recettes et dépenses, qu’on peut définir ainsi:

• Actif: l’argent qu’on possède
• Passif: l’argent qu’on doit
• Dépenses (ou Charges): l’argent qui sort
• Recettes (ou Produits): l’argent qui rentre

Si on reprend l’exemple précédent, on voit facilement que:

• Le compte “Banque” est un compte d’actif
• Le compte “Fournitures de bureau” est un compte de dépenses
• Le compte “Salaire” est un compte de recettes

Les comptes de passif sont utilisés par exemple lorsqu’on achète un bien à crédit. Supposons que vous achetez vos ramettes de papier le 12 mai, et que vous payez le fournisseur (METRO par exemple) une semaine plus tard. Dans ce cas, il y a deux transactions à enregistrer dans la comptabilité:

Le compte “Magasin METRO” (compte de fournisseur) est ici un compte de passif, car il correspond à une dette.

Si on fait la somme des opérations, on voit que le tout revient à transférer 50 euros du compte “Banque” vers le compte “Fournitures de bureau”, car les opérations sur le compte “Magasin METRO” s’annulent une fois que la facture a été payée. Un des intérêts de la comptabilité en partie double est qu’elle permet de comptabiliser correctement ce genre de dettes, même si elles ne sont que temporaires. Dans le cas d’un crédit immobilier, la dette peut durer de nombreuses années donc il est encore plus important d’en garder une trace !

Pour être tout à fait complet, il faut préciser que le passif se compose en réalité de deux parties: les Dettes et le Capital. Dans la comptabilité anglo-saxonne, le capital est une catégorie de compte à part entière, alors que dans la comptabilité française, dettes et capital sont regroupés sous le même terme de “passif”. La notion de capital n’est pas forcément intuitive, disons pour faire simple que dans le cas d’une entreprise, le capital représente la valeur de cette entreprise, c’est-à-dire l’actif moins les dettes. Dit autrement, le capital représente la dette de l’entreprise vis-à-vis de ses propres actionnaires (ou associés), c’est d’ailleurs pourquoi il est classé parmi les comptes de passif.

En pratique, il suffit de se souvenir que l’actif doit toujours être égal au passif, car tout ce qu’une société possède est une dette envers quelqu’un d’autre (envers les créanciers ou les associés). Le capital peut donc être considéré comme une “astuce” technique pour équilibrer les comptes: si l’actif est supérieur aux dettes (ce que je vous souhaite), la différence entre les deux se retrouve automatiquement au capital.

Pour finir, il est utile de remarquer que les comptes d’actif et de passif permettent d’évaluer l’état des finances d’une entreprise à n’importe quel instant, et sont appelés comptes de bilan. D’un autre côté, les comptes de recettes et de dépenses traduisent les mouvements financiers de l’entreprise sur une période donnée, et sont appelés comptes de gestion. Dans une entreprise, les comptes de gestion sont remis à zéro (soldés) chaque année lors de la clôture des comptes, et au passage le solde restant (appelé résultat de l’exercice comptable, ou également bénéfice lorsqu’il est positif) est transféré sur un compte de capital.

Débit et crédit

L’approche que j’ai décrite jusqu’ici (et qui est celle utilisée dans Beancount) pourra sembler surprenante à ceux qui ont déjà des notions de comptabilité.

En réalité, les comptables ne représentent pas les transferts entre comptes par des montants positifs ou négatifs, mais utilisent les notions (peu intuitives au premier abord) de débit et crédit:

• Un débit représente une entrée vers un compte
• Un crédit représente une sortie depuis un compte

Dans une écriture comptable, on note les débits et crédits dans deux colonnes différentes, le débit étant toujours à gauche, et le crédit à droite, et on utilise seulement des nombres positifs.

Si on reprend notre exemple initial, les transactions s’écrivent dans un comptabilité traditionnelle sous la forme suivante:

Le principe est le même que précédemment, mais au lieu d’utiliser des montants positifs pour les entrées d’argent, on écrit les montants dans la colonne “débit”, et au lieu d’utiliser des montants négatifs pour les sorties, on écrit les montants dans la colonne “crédit”, toujours en utilisant des nombres positifs.

Avec cette méthode, le calcul du solde des comptes est plus compliqué, puisqu’il faut manipuler des débits et des crédits au lieu de faire une simple addition. Si la somme des débits est supérieure à la somme des crédits, le solde du compte est débiteur, et si la somme des crédits est supérieure à la somme des débits, le solde du compte est créditeur.

Avec notre exemple, on obtient:

Tout serait bien plus simple en se limitant à l’utilisation des nombres positifs et négatifs, comme le fait Beancount, mais des siècles d’histoire de la comptabilité en ont décidé autrement (en réalité, la séparation des opérations en débits et crédits a bien une utilité en pratique, par exemple pour détecter les erreurs de saisie et les fraudes).

Pour ajouter à la confusion, cette terminologie débit / crédit est exactement l’inverse de ce que vous pouvez trouver chaque mois sur votre relevé bancaire, puisqu’un compte en banque est toujours censé être créditeur et non débiteur ! En fait le paradoxe s’explique facilement: du point de vue de votre banque, l’argent disponible sur votre compte est de l’argent qu’elle vous doit, c’est donc un crédit pour elle. Par contre de votre point de vue, la situation est exactement l’inverse et cet argent est donc compté comme un débit.

À noter que les comptes d’actif et de dépenses sont en principe toujours débiteurs (donc “positifs”), et les comptes de passif et de recettes sont en principe toujours créditeurs (donc “négatifs”).

Plan de comptes

Le dernier point à aborder est la notion de plan de comptes. C’est tout simplement la liste de tous les comptes utilisés pour effectuer la comptabilité.

En France, il est obligatoire de suivre une réglementation appelée Plan Comptable Général (PCG) pour faire la comptabilité d’une entreprise. Le PCG définit un plan de compte standard, qui classe les différents comptes en 7 catégories principales, et attribue un numéro à chaque type de compte. Le compte “Fournitures consommables” porte par exemple le numéro 6022, et il contient (entre autres) un sous-compte “Fournitures de bureau” qui porte le numéro 60225.

Pour une comptabilité personnelle, il est inutile de suivre les recommendations du PCG, mais il faut tout de même réfléchir à la liste des comptes qu’on doit utiliser, et à la manière des les classer.

Dans Beancount, chaque compte doit être affecté à une des 5 catégories suivantes:

• Assets (Actif)
• Liabilities (Passif)
• Equity (Capital)
• Income (Recettes)
• Expenses (Dépenses)

Comme expliqué précédemment, le Capital est une catégorie à part dans le système anglo-saxon, qui est utilisé par Beancount.

Par défaut ces noms sont en anglais dans Beancount, mais il est possible de définir une option pour les renommer en français (ou en n’importe quoi).

Un plan de compte utilisable dans Beancount pourrait ressembler à ceci:

• Actif:LCL:CompteCheques
• Actif:LCL:LivretA
• Passif:LCL:CreditImmobilier
• Recettes:Salaire
• Recettes:Loyer
• Depenses:Charges:RemboursementCredit
• Depenses:Charges:Electricite
• Depenses:Charges:Telephone
• Depenses:Charges:Imports
• Depenses:Alimentation
• Depenses:Loisirs
• Depenses:Sante
• Depenses:Vetements
• Depenses:Transports
• Depenses:Transports:Voiture
• Depenses:Logement
• Depenses:Autres

L’utilisation du séparateur “:” permet de définir une hiérarchie de comptes, par exemple “Depenses:Transport:Voiture” est un sous-compte du compte “Depenses:Transport”. Ce n’est pas obligatoire, mais permet de mieux s’y retrouver quand on utilise un grand nombre de comptes (l’exemple précédent est très simplifié; j’utilise personnellement une centaine de comptes différents).

Une petite limitation de Beancount est qu’il n’est pas possible d’utiliser des espaces dans un nom de compte, il faut donc utiliser des tirets à la place, ou coller les mots comme je l’ai fait dans l’exemple.

Fonctionnement général de Beancount

Grâce à ces notions de base de comptabilité, il est maintenant possible de rentrer dans le vif du sujet, à savoir le fonctionnement de Beancount.

Contrairement à la majorité des logiciels de comptabilité, Beancount se lance en ligne de commande, et n’a donc pas besoin d’interface graphique. Son auteur, Martin Blais, s’est inspiré de Ledger, qui fonctionne sur le même principe.

L’idée principale est d’utiliser un langage spécifique (un Domain Specific Language ou DSL, en anglais) pour décrire ses transactions dans un simple fichier texte. Une fois que ce fichier est écrit (avec n’importe quel éditeur de texte), Beancount fournit différents outils pour en tirer divers rapports et statistiques, sans jamais modifier le fichier original. Il est également possible d’accéder à certains rapports avec une interface Web, qui est très pratique pour naviguer dans les comptes, mais ne permet pas de toute façon de modifier le fichier de comptes.

Le format utilisé pour décrire les transactions a été conçu pour être facilement manipulable à la fois par un humain ou par un programme, contrairement à la quasi-totalité des autres formats existants.

Il est temps de passer à la pratique ! En langage Beancount, notre exemple d’achat de papier s’écrit comme ceci:

2015-05-12 * "Achat papier"
  Actif:Banque                    -50.00 EUR
  Depenses:FournituresDeBureau     50.00 EUR

Le format est extrêmement simple: chaque transaction commence par une ligne avec la date et une description, puis en dessous on écrit les opérations pour les différents comptes impactés par la transaction. On remarque qu’il n’est pas question ici de débits et crédits: la notation utilise des montants positifs et négatifs comme expliqué dans l’introduction.

Étant donné que la somme des écritures d’une même transaction doit toujours être nulle, il est possible de laisser Beancount calculer automatiquement le montant d’une des écritures, ce qui donne la forme simplifiée suivante:

2015-05-12 * "Achat papier"
  Actif:Banque                    -50.00 EUR
  Depenses:FournituresDeBureau

En fait avant d’enregistrer des transactions, il faut d’abord ouvrir les comptes utilisés, grâce à la directive “open”. Par exemple on ouvre le compte “Banque” comme ceci:

2000-01-01 open Actif:Banque EUR

L’ordre des écritures dans le fichier n’a pas d’importance, par contre les dates doivent être cohérentes, il faut donc évidemment que le compte soit ouvert avant d’apparaître dans une transaction.

Voici maintenant un exemple complet de fichier Beancount, qu’on appelera par exemple “compta.beancount”:

; Options pour renommer les catégories de base
option "name_assets" "Actif"
option "name_liabilities" "Passif"
option "name_equity" "Capital"
option "name_income" "Recettes"
option "name_expenses" "Depenses"
option "account_previous_balances" "SoldeOuverture"
option "account_previous_earnings" "Benefice:Precedents"
option "account_current_earnings" "Benefice:Courant"

; Ouverture des comptes
2000-01-01 open Actif:Banque EUR
2000-01-01 open Passif:MagasinMETRO EUR
2000-01-01 open Capital:SoldeOuverture EUR
2000-01-01 open Recettes:Salaire EUR
2000-01-01 open Depenses:FournituresDeBureau EUR

; Complète automatiquement le solde d'ouverture
2000-01-01 pad Actif:Banque Capital:SoldeOuverture

; Dernier solde connu
2015-05-31 balance Actif:Banque  2640.00 EUR

; Journal des écritures 

2015-05-12 * "Achat papier facture 123456"
  Passif:MagasinMETRO             -50.00 EUR
  Depenses:FournituresDeBureau

2015-05-19 * "Paiement facture METRO 123456"
  Actif:Banque                    -50.00 EUR
  Passif:MagasinMETRO

2015-05-30 * "Salaire mai 2015"
  Actif:Banque                   2000.00 EUR
  Recettes:Salaire

Les options ne sont pas nécessaires si vous souhaitez garder les noms par défaut en anglais.

Cet exemple montre également une fonctionnalité extrêmement pratique de Beancount, qui est le remplissage automatique des “trous” dans la comptabilité, grâce aux directive “pad” et “balance”:

• “balance” permet d’indiquer le solde connu d’un compte à une certaine date
• “pad” permet d’insérer automatiquement une écriture pour que le solde du compte soit respecté

Dans cet exemple, la directive “pad” est équivalente à la transaction suivante:

2000-01-01 * "Remplissage automatique"
  Actif:Banque                   690.00 EUR
  Capital:SoldeOuverture        -690.00 EUR

Le solde initial du compte est donc calculé automatiquement, alors qu’on ne connaissait que le solde final.

Au passage on remarque que le solde initial du compte “Banque” est pris depuis le compte “Capital:SoldeOuverture”, qui est dédié à ce genre d’opérations. En effet l’argent doit toujours venir de quelque part, et ce compte représente le capital que l’on possédait avant de démarrer sa comptabilité sous Beancount.

Voilà, maintenant que nous avons un fichier Beancount, il faut bien faire quelque chose avec ! Pour commencer, nous pouvons utiliser la commande “bean-report” pour produire différents rapports, par exemple le solde courant de chaque compte, ce qu’on appelle la balance des comptes:

> bean-report compta.beancount balances
Actif:Banque                     2,640.00 EUR
Capital:SoldeOuverture            -690.00 EUR
Depenses:FournituresDeBureau        50.00 EUR
Passif:MagasinMETRO          
Recettes:Salaire                -2,000.00 EUR

On peut aussi par exemple afficher le journal (l’ensemble des écritures) d’un compte donné, comme ceci:

> bean-report compta.beancount journal -a Passif:MagasinMETRO
2000-01-01 open  Passif:MagasinMETRO
2015-05-12 *     Achat papier facture 123456                     -50.00 EUR
2015-05-19 *     Paiement facture METRO 123456                    50.00 EUR

La façon la plus simple d’explorer ses comptes reste encore l’interface Web, qui se lance avec la commande “bean-web”:

> bean-web compta.beancount

Par défaut, l’interface est accessible à l’adresse http://127.0.0.1:8080/. Elle permet de visualiser le journal, le bilan, la balance des comptes, et le compte de résultat, éventuellement par année.

Voici par exemple le bilan (balance sheet en anglais) de notre exemple pour l’année 2015, c’est-à-dire le tableau récapitulant le solde de tous les comptes d’actif et passif:

Importation automatique des transactions

Bien sûr il n’est pas très pratique de rentrer à la main toutes les transactions, surtout en l’absence d’interface graphique pour faciliter la tâche.

La solution la plus pratique consiste à exporter ses comptes depuis le site de sa banque (au format CSV, Quicken, OFX, ou autre) et de convertir les fichiers automatiquement au format Beancount, par exemple grâce à l’outil LedgerHub (du même auteur).

Il est toujours possible de rectifier le fichier obtenu après coup, par exemple pour ajouter des remarques ou éliminer des doublons.

Requêtes personnalisées avec bean-query

Si on veut obtenir des rapports plus précis, il est possible d’utiliser l’outil “bean-query”, qui fournit un langage de requêtes similaire à SQL:

> bean-query compta.beancount
Input file: "Beancount"
Ready with 11 directives (8 postings in 4 transactions).
beancount>

Si on veut par exemple retrouver toutes les transactions dont la description contient le texte “123456” (un numéro de facture en l’occurence) pendant l’année 2015, on peut lancer la requête suivante:

beancount> SELECT date, account, narration, change WHERE narration ~ "123456" AND year = 2015
   date              account                      narration             change  
---------- ---------------------------- ----------------------------- ----------
2015-05-12 Passif:MagasinMETRO          Achat papier facture 123456   -50.00 EUR
2015-05-12 Depenses:FournituresDeBureau Achat papier facture 123456    50.00 EUR
2015-05-19 Actif:Banque                 Paiement facture METRO 123456 -50.00 EUR
2015-05-19 Passif:MagasinMETRO          Paiement facture METRO 123456  50.00 EUR

On peut aussi regrouper les résultats par compte, en affichant uniquement la somme des écritures pour chaque compte:

beancount> SELECT account, SUM(change) WHERE narration ~ "123456" AND year = 2015 GROUP by account
          account            sum_change
---------------------------- ----------
Depenses:FournituresDeBureau  50.00 EUR
Actif:Banque                 -50.00 EUR
Passif:MagasinMETRO

Avec cet exemple, on vérifie ainsi que le compte “Passif:MagasinMETRO” a un solde nul, ce qui signifie que la facture a bien été payée.

Les possibilités sont sans fin, il ne reste plus qu’à faire preuve d’imagination !

Scripts et plugins en Python

Pour finir, voyons comment écrire ses propres programmes en utilisant l’API Python de Beancount.

Rien ne vaut un exemple, donc voici un petit programme Python qui ouvre un fichier Beancount, et affiche la date et la description de toutes les transactions:

#!/usr/bin/env python3

from beancount import loader
from beancount.core.data import Transaction

PATH = "compta.beancount"
entries, errors, options = loader.load_file(PATH)
for entry in entries:
    if isinstance(entry, Transaction):
        print(entry.date, entry.narration)

L’exécution du programme produit le résultat suivant:

2000-01-01 (Padding inserted for Balance of 2640.00 EUR for difference 690.00 EUR)
2015-05-12 Achat papier facture 123456
2015-05-19 Paiement facture METRO 123456
2015-05-30 Salaire mai 2015

Et voilà ! J’espère vous avoir donné un bon aperçu des possibilités de Beancount, et pour plus de détails il vous reste à lire la documentation sur le site du projet !