Modéliser le barème fiscal belge en C# : du brut au net

Cotisations ONSS, bonus à l’emploi, précompte professionnel, cotisation spéciale de sécurité sociale : comment je structure le moteur de calculateur-de-salaire.be pour qu’il reste exact quand les barèmes changent, plusieurs fois par an.

Le problème : des règles qui changent plus vite que le code

Sur papier, le passage du brut au net tient en quelques soustractions. Dans le moteur de calculateur-de-salaire.be, ces soustractions dépendent de plusieurs dizaines de paramètres : taux, tranches, plafonds, montants forfaitaires. Et chacun a sa propre date d’entrée en vigueur.

Entre août et novembre 2026, trois changements touchant le net sont entrés en vigueur, à trois dates différentes. Le taux du bonus à l’emploi fiscal pour les très bas salaires est passé à 63 % au 1er août. Le volet « bas salaires » du bonus à l’emploi social a été revu au 1er septembre. L’impôt sur la quotité exemptée et le plafond du quotient conjugal ont changé au 1er novembre, dans la foulée de la réforme de l’impôt des personnes physiques.

S’y ajoutent les cas particuliers. Un ouvrier cotise sur 108 % de son brut. Un temps partiel voit son bonus à l’emploi calculé sur un salaire de référence temps plein, puis proratisé. Un couple à revenu unique bénéficie du quotient conjugal. Prise isolément, chaque règle est simple. Leur enchaînement ne l’est pas : une erreur d’ordre ou d’arrondi en amont se propage jusqu’au net.

Les montants cités dans cet article sont ceux que le moteur applique aux rémunérations de 2026, repris de sa configuration.

Avertissement. Cet article est informatif et ne constitue pas un conseil fiscal. Pour simuler votre situation, utilisez calculateur-de-salaire.be.

Les étapes du calcul, dans l’ordre

Le moteur est une chaîne de calculateurs. Chacun implémente la même interface : il reçoit la demande (brut, statut, situation familiale, personnes à charge…) et la réponse en cours, et y ajoute ses propres lignes.

public interface ICalculateur
{
    CalculerSalaireResponse Calculer(CalculerSalaireRequest request, CalculerSalaireResponse response);
}

Le service principal appelle ces calculateurs l’un après l’autre. L’ordre d’appel est une règle métier à part entière, lisible à un seul endroit. Le tableau ci-dessous le résume pour un salarié.

ÉtapeCe que le moteur calculeParamètres 2026
1. Cotisations personnelles ONSS13,07 % du brut ; pour un ouvrier, du brut porté à 108 %13,07 %
2. Bonus à l’emploi socialRéduction de ces cotisations en deux volets dégressifs, plafonnée aux cotisations duesEmployé : volet B de 171,99 €, éteint à 2 937,93 € ; volet A de 127,54 €, éteint à 3 403,62 €
3. Revenu imposableBrut − cotisations + bonus à l’emploi—
4. Précompte professionnelBarème annuel par tranches, après frais forfaitaires et quotité exemptée, ramené au moisTranches à 26,75 / 42,80 / 48,15 / 53,50 %
5. Réductions de précompteEnfants et autres personnes à charge, handicap, bonus à l’emploi fiscalBonus fiscal : 33,14 % du volet A, 63 % du volet B
6. Cotisation spéciale de sécurité socialeCalculée sur le revenu trimestriel, retenue sur le netPar tranches, selon la situation du ménage
7. NetImposable − précompte − cotisation spéciale + suppléments nets—

Deux subtilités montrent pourquoi l’ordre compte.

D’abord, le bonus à l’emploi ne peut pas dépasser les cotisations personnelles dues. Quand c’est le cas, l’excédent est retiré d’abord du volet B (« très bas salaires »), puis du volet A, et pas au prorata : c’est ce que prévoient les instructions administratives de l’ONSS. Comme le volet B porte le taux fiscal le plus élevé (63 % contre 33,14 %), l’ordre d’écrêtement modifie le précompte, donc le net. Le bonus fiscal se calcule ensuite sur les montants réellement octroyés, après écrêtement.

Ensuite, le précompte se calcule sur une base annuelle. Le moteur multiplie le revenu imposable mensuel par 12, déduit les frais professionnels forfaitaires (30 %, plafonnés à 6 070 € par an), applique le barème, retranche l’impôt sur la quotité exemptée (3 089,63 € depuis le 1er novembre 2026, contre 2 987,98 € auparavant), puis divise par 12. Pour un couple à revenu unique, 30 % du revenu imposable est attribué au conjoint, dans la limite de 11 780 € depuis le 1er novembre, et la quotité exemptée est déduite deux fois. Les réductions pour enfants à charge sont des montants annuels ramenés au mois : depuis le 1er novembre, 684 € par an pour un enfant, 1 644 € pour deux.

La cotisation spéciale de sécurité sociale, enfin, est définie par trimestre. Le moteur, qui raisonne au mois, multiplie le brut par trois, applique la tranche, borne le résultat entre un minimum et un maximum, puis redivise par trois. Pour un isolé, elle plafonne à 182,82 € par trimestre.

Des paramètres annuels versionnés, pas des constantes

Mettre les taux dans des constantes C# est tentant : c’est lisible et typé. Le problème apparaît le jour où il faut calculer octobre avec les anciens barèmes et novembre avec les nouveaux, ou expliquer six mois plus tard pourquoi une simulation donnait tel montant.

Dans le moteur, les barèmes vivent dans un fichier JSON lié à une classe d’options typée. Ce socle porte une version : un identifiant, une date d’entrée en vigueur et une date de dernière vérification face aux sources officielles. Les deux dates ne se confondent jamais. La première dit quand la règle s’applique, la seconde quand la valeur a été contrôlée pour la dernière fois.

Chaque changement réglementaire ajoute ensuite un fichier daté, nommé d’après sa date d’entrée en vigueur, qui ne contient que ce qui change. Celui du 1er novembre 2026 tient en quelques lignes (extrait) :

{
  "BaremesVersion": {
    "Identifiant": "2026.7",
    "EntreeEnVigueurLe": "2026-11-01",
    "DerniereVerificationLe": "2026-10-16"
  },
  "ChiffresClef": {
    "TrancheNonImpose": 3089.63,
    "PlafondQuotientConjugal": 11780
  }
}

Au démarrage, un calendrier empile le socle et les fichiers datés dans l’ordre. Il lève une exception dès le chargement si un fichier est incohérent : nom différent de sa date, date antérieure au jeu précédent, identifiant réutilisé. Choisir le jeu applicable tient ensuite en une ligne :

public CalculateurOptions Pour(DateOnly date) =>
    Jeux.LastOrDefault(j => j.BaremesVersion.EntreeEnVigueurLe <= date) ?? Jeux[0];

Quelques détails m’ont évité des erreurs difficiles à repérer :

  • Aucun tableau dans un fichier daté. La configuration .NET fusionne les tableaux index par index : un tableau de tranches plus court laisserait survivre les dernières tranches du socle. Le calendrier rejette donc tout fichier daté qui contient un tableau.
  • La date du jour se calcule à l’heure de Bruxelles, via un TimeProvider injecté. Le changement de barème a lieu à minuit à Bruxelles, pas à minuit UTC, et un test le vérifie.
  • Chaque simulation enregistrée porte la version des barèmes qui l’a produite. Un document généré début novembre 2026 mentionne « Calcul effectué avec les barèmes 2026.7 (en vigueur depuis le 01/11/2026) », ce qui permet d’expliquer un écart longtemps après.
  • Chaque jeu de valeurs cite ses sources dans le fichier lui-même : arrêté royal, date de publication au Moniteur belge, numéro NUMAC. Quand un chiffre est contesté, la réponse est dans le dépôt.

Tout n’est pas encore dans les jeux datés, et je préfère le dire. Quelques taux restent écrits dans le code C#, comme les 13,07 % de cotisations personnelles ou les taux du bonus à l’emploi fiscal, ces derniers documentés avec leur texte source et leur date d’effet. C’est un compromis : un changement de ces taux passe par une modification de code et un déploiement, là où un barème daté ne demande qu’un fichier.

Représenter les montants : decimal, et un arrondi au bon moment

Tous les montants sont des decimal. Un double ne représente pas exactement 0,1 ; sur une chaîne de multiplications par des taux comme 0,1307, l’écart finit par toucher le centime.

La vraie question est le moment de l’arrondi. Le moteur n’arrondit pas chaque ligne. Chaque calculateur ajoute à la réponse une ligne typée (cotisation, bonus, précompte, retenue…) avec un montant en pleine précision et un libellé. Les totaux par catégorie sont obtenus en sommant ces lignes, puis arrondis au centime avec MidpointRounding.AwayFromZero, l’arrondi commercial. Par défaut, Math.Round arrondit au pair le plus proche, source d’écarts d’un centime difficiles à expliquer. Le revenu imposable et le net sont arrondis de la même manière.

Ce journal de lignes a un autre intérêt : le détail affiché à l’utilisateur est exactement ce qui a été calculé, pas une reconstitution après coup.

L’exception confirme la règle. Quand un texte impose un arrondi intermédiaire, le code le reproduit à l’endroit exact. Pour le bonus à l’emploi d’un temps partiel, les instructions de l’ONSS arrondissent au centime le salaire de référence, le montant de base et le montant octroyé, et la fraction de prestations à deux décimales. Le moteur fait de même, ni plus ni moins.

À l’inverse, une règle d’arrondi abrogée doit quitter le code. L’arrondi du revenu à la tranche inférieure de 15 €, supprimé au 1er janvier 2023, a été retiré, et les cas de test concernés ont été recalculés.

Appliquer un barème progressif par tranches

Le barème du précompte professionnel est progressif. Pour 2026, le moteur applique ces tranches au revenu annuel, après déduction des frais forfaitaires :

  • jusqu’à 16 710 € : 26,75 % ;
  • de 16 710 à 29 500 € : 42,80 % ;
  • de 29 500 à 51 050 € : 48,15 % ;
  • au-delà de 51 050 € : 53,50 %.

Plutôt que de boucler sur les tranches à chaque calcul, chaque tranche porte l’impôt cumulé des tranches précédentes : 4 469,93 € pour la deuxième, soit 26,75 % de 16 710 €. Voici une version simplifiée, sur le modèle du moteur :

public sealed record Tranche(decimal Minimum, decimal MontantFixe, decimal Pourcentage);

public sealed record ParametresPrecompte(
    IReadOnlyList<Tranche> Tranches,
    decimal TauxFraisForfaitaires,
    decimal PlafondFraisForfaitaires,
    decimal ImpotSurQuotiteExemptee);

public static class Precompte
{
    public static decimal ImpotAnnuel(decimal brutImposableAnnuel, ParametresPrecompte p)
    {
        var frais = Math.Min(brutImposableAnnuel * p.TauxFraisForfaitaires, p.PlafondFraisForfaitaires);
        var baseImposable = brutImposableAnnuel - frais;
        if (baseImposable <= 0m)
        {
            return 0m;
        }

        var tranche = p.Tranches.Last(t => t.Minimum < baseImposable);
        var impot = tranche.MontantFixe
                  + (baseImposable - tranche.Minimum) * tranche.Pourcentage / 100m;

        return Math.Max(impot - p.ImpotSurQuotiteExemptee, 0m);
    }

    public static decimal Mensuel(decimal brutImposableMensuel, ParametresPrecompte p) =>
        ImpotAnnuel(brutImposableMensuel * 12m, p) / 12m;
}

Avec les valeurs de 2026, les tranches deviennent new(0m, 0m, 26.75m), new(16710m, 4469.93m, 42.80m), new(29500m, 9944.05m, 48.15m) et new(51050m, 20320.38m, 53.50m), avec TauxFraisForfaitaires = 0.30m, PlafondFraisForfaitaires = 6070m et ImpotSurQuotiteExemptee = 3089.63m. Quelques choix méritent une explication :

  • Les paramètres arrivent en argument, sous forme de record immuable. La méthode ne lit ni la date du jour ni la configuration : elle est pure, donc testable avec n’importe quel barème, y compris un barème périmé.
  • L’impôt cumulé est une donnée, rangé à côté du taux. Chaque tranche se vérifie à la calculatrice, sans exécuter le code.
  • Le résultat ne descend jamais sous zéro. Pour un bas salaire, l’impôt sur la quotité exemptée dépasse l’impôt calculé : le précompte est nul, pas négatif.
  • Les bornes sont traitées explicitement. Le vrai code prévoit un repli pour une valeur qui tombe exactement sur une limite de tranche. C’est le genre de cas qu’un test paramétré attrape et qu’une relecture laisse passer.

Le calcul inverse, du net vers le brut, n’a pas de formule fermée. La fonction net(brut) est en escalier : arrondis au centime, changements de tranche, seuils du bonus à l’emploi. Le moteur tente d’abord la méthode de Newton-Raphson, qui converge vite sur une fonction lisse, puis bascule sur une recherche dichotomique quand elle stagne, avec une tolérance d’un centime.

Tester un moteur fiscal

Le dépôt sépare deux familles de tests, et c’est sans doute la décision la plus utile du projet.

Les tests d’algorithme injectent un barème figé, écrit dans le test lui-même (des valeurs de 2025), et vérifient des cas de référence avec [Theory] et [InlineData] : un brut en entrée, un précompte attendu au centime. Ils ne cassent pas quand la configuration de production évolue, et ils documentent l’algorithme mieux qu’un commentaire.

Les tests de configuration chargent les vrais fichiers et vérifient ce qui doit être vrai à une date donnée. Le 31 octobre 2026, le jeu 2026.6 s’applique ; le 1er novembre, le jeu 2026.7 ; la bascule a lieu à 23 h UTC, soit minuit à Bruxelles. D’autres tests comparent deux dates. Le jeu du 11 novembre, qui n’ajoute que des paramètres pour les indépendants, ne doit changer aucun net salarial. Et pour un isolé, le gain de net au 1er novembre doit valoir, au centime près, la hausse de l’impôt sur la quotité exemptée divisée par douze.

Un dernier garde-fou vise le contenu du site. Les chiffres publiés dans les pages sont recensés dans un registre unique, avec les valeurs qu’ils remplacent, et un test échoue si une ancienne valeur réapparaît quelque part. Un moteur juste ne suffit pas si un texte explicatif continue d’afficher le taux de l’an dernier.

Ce que je recommande en complément : confronter régulièrement une poignée de profils types (isolé, couple à revenu unique, ouvrier, temps partiel) aux simulateurs officiels et aux décomptes de secrétariats sociaux, puis transformer chaque écart expliqué en cas de test. Un écart inexpliqué, lui, est un bug jusqu’à preuve du contraire.

Ce que j’en retiens

  • L’ordre des étapes fait partie des règles. Il doit se lire dans le code, à un seul endroit.
  • Un barème est une donnée datée et sourcée. Idéalement, le code de calcul ne sait pas en quelle année on est.
  • On arrondit là où le texte l’exige, avec le mode d’arrondi qu’il exige, et nulle part ailleurs.
  • Ce qui n’est pas modélisé s’écrit. Le moteur documente ses limites assumées, par exemple le report sur le mois suivant de l’excédent de bonus à l’emploi, qu’un simulateur mensuel n’intègre pas. Une limite connue vaut mieux qu’une précision supposée.

Ces principes dépassent la paie : tarification, primes, indemnités, calculs réglementaires. Dès que des règles métier évoluent dans le temps, la même structure s’applique.

Des règles métier complexes à traduire en code ?

Paie, fiscalité, tarification, calculs réglementaires : je conçois en .NET des moteurs de calcul testés et maintenables. Parlons de votre cas.

Me contacter