Direct naar de inhoud
test-nummers.nl

ISO-standaarden · 15 min lezen

IBAN MOD-97 implementeren — drie valkuilen vergeleken

Door Alex · Gepubliceerd 17 april 2026

Deel:

IBAN-validatie volgens ISO 7064 MOD-97 lijkt triviaal: permuteren, letters vervangen door cijfers, modulo 97, controleer of het resultaat 1 is. In de praktijk falen veel implementaties op lange IBAN's (Malta: 31 tekens, Saint Lucia: 32), accepteren ze syntactisch ongeldige formatting, of zijn ze onnodig traag door string-allocatie. Dit artikel vergelijkt drie strategieën op correctheid, leesbaarheid en performance, en benoemt drie formatting-fouten waardoor geldige IBAN's onterecht worden geweigerd.

1. De ISO 7064 MOD-97-10 formule

Stappen van de standaard in gecondenseerde vorm:

  1. Verwijder alle spaties en maak hoofdletters van de invoer.
  2. Verplaats de eerste vier tekens (landcode + controle) naar het einde.
  3. Vervang elke letter A–Z door twee cijfers: A=10, B=11, …, Z=35.
  4. Bereken de resulterende grote integer modulo 97.
  5. De IBAN is geldig als de rest gelijk is aan 1.

Voor een Nederlandse IBAN NL91ABNA0417164300 levert stap 2 op: ABNA0417164300NL91. Stap 3 zet N→23, L→21, A→10, B→11: 101123100417164300232191. Stap 4 geeft modulo 97 = 1, dus geldig. Dezelfde stappen met je eigen bankcode en rekeningnummer zie je in IBAN berekenen.

2. Strategie A — BigInt

function isValidIbanBigInt(iban: string): boolean {
  const normalized = iban.replace(/\s+/g, '').toUpperCase();
  if (!/^[A-Z]{2}\d{2}[A-Z0-9]{11,30}$/.test(normalized)) return false;
  const rearranged = normalized.slice(4) + normalized.slice(0, 4);
  const numeric = rearranged.replace(/[A-Z]/g, (c) =>
    String(c.charCodeAt(0) - 55),
  );
  return BigInt(numeric) % 97n === 1n;
}

Leesbaar en correct. Nadeel: voor elke controle bouw je een tussenstring en een BigInt. Voor losse IBAN's maakt dat niets uit; bij batchvalidatie is strategie C sneller.

3. Strategie B — Chunked modulo

De klassieke "horner-achtige" aanpak: verwerk de string in blokken van 9 cijfers zodat de tussenstappen in een gewone JavaScript Number passen (2⁵³ > 10⁹·97).

function isValidIbanChunked(iban: string): boolean {
  const normalized = iban.replace(/\s+/g, '').toUpperCase();
  if (!/^[A-Z]{2}\d{2}[A-Z0-9]{11,30}$/.test(normalized)) return false;
  const rearranged = normalized.slice(4) + normalized.slice(0, 4);
  const numeric = rearranged.replace(/[A-Z]/g, (c) =>
    String(c.charCodeAt(0) - 55),
  );
  let remainder = 0;
  for (let i = 0; i < numeric.length; i += 9) {
    const chunk = (remainder === 0
      ? numeric.slice(i, i + 9)
      : remainder.toString() + numeric.slice(i, i + 9));
    remainder = Number(chunk) % 97;
  }
  return remainder === 1;
}

Geen BigInt, maar wel tussenstrings per blok. Het voordeel is dat dit ook werkt in omgevingen zonder BigInt; sneller dan BigInt is het in onze meting niet (zie benchmark hieronder).

4. Strategie C — Vooruit rekenen zonder string-conversie

Nog sneller is helemaal geen string te bouwen. We houden een numerieke restwaarde bij en verwerken elk teken direct:

function isValidIbanFast(iban: string): boolean {
  const normalized = iban.replace(/\s+/g, '').toUpperCase();
  if (!/^[A-Z]{2}\d{2}[A-Z0-9]{11,30}$/.test(normalized)) return false;

  // Eerst de tekens vanaf positie 4, daarna de eerste 4 (zonder hulparray)
  const n = normalized.length;
  let r = 0;
  for (let k = 0; k < n; k++) {
    const code = normalized.charCodeAt((k + 4) % n);
    if (code >= 48 && code <= 57) {
      // 0-9
      r = (r * 10 + (code - 48)) % 97;
    } else {
      // A-Z: letter wordt twee cijfers (A=10 … Z=35)
      r = (r * 100 + (code - 55)) % 97;
    }
  }
  return r === 1;
}

Deze variant vermijdt na de normalisatie zowel BigInt als string-concatenatie. In onze meting is hij ruim vijf keer zo snel als A en B, ook op lange IBAN's (Malta/MT: 31 tekens). Let op: bouw je hier toch een array met posities, dan ben je die winst weer kwijt.

5. Benchmark (Node 22.13, Intel Core i7-14650HX)

StrategieNL-IBAN (18 tekens)MT-IBAN (31 tekens)Extra allocaties
A — BigInt~1,6 M ops/s~1,0 M ops/sTussenstring + BigInt
B — Chunked~1,5 M ops/s~0,85 M ops/sTussenstrings per blok
C — Char-by-char~7,9 M ops/s~4,9 M ops/sGeen (na normalisatie)

Gemeten met 1 miljoen aanroepen per variant, beste van 9 runs, inclusief normalisatie en regex-check. De generator op /iban-generator gebruikt een variant van strategie C: één lus per teken, met een aparte tak voor kleine letters. Bij een ongeldig teken geeft die functie NaN terug, zodat een fout nooit stil als "geldig" doorloopt. Voor losse controles in een formulier is elke strategie snel genoeg.

6. De drie formatting-valkuilen

Drie formatting-fouten zorgen ervoor dat een geldige IBAN toch als "ongeldig" wordt geweigerd:

  1. Unicode-spaties. Wie een IBAN kopieert uit Word, Outlook of een webpagina, krijgt soms een non-breaking space (U+00A0) in plaats van een gewone spatie (U+0020). De regex /\s+/g vangt dit in JavaScript, maar een / +/g niet — en dat laatste is wat veel snippets laten zien.
  2. Streepjes en punten. In geplakte invoer staat een IBAN soms als NL91-ABNA-0417-1643-00 of met punten. Strikte validatie faalt hier terecht, maar een gebruiksvriendelijke UI moet streepjes en punten eerst strippen voordat ze de regex-check toepast. De IBAN-validator op deze site doet dat ook.
  3. Lowercase letters. De ISO-standaard schrijft hoofdletters voor, maar in plakinvoer komt nl91abna0417164300 vaak voor. Zonder .toUpperCase() voor de regex-match wordt dit ten onrechte geweigerd.

7. Edge cases die je niet wilt missen

  • Lengte per land.Een IBAN heeft een vaste lengte per land: 18 voor NL, 22 voor DE, 24 voor ES, 31 voor MT. Een IBAN van 22 tekens met landcode "NL" is syntactisch ongeldig, ook als hij MOD-97 wel passeert. Validatie moet de verwachte lengte per landcode opzoeken.
  • Fantoom-IBAN's. Er circuleren IBAN-achtige formaten van landen die niet in het officiële SWIFT IBAN-register staan. Hanteer een allowlist van landcodes uit het register (bij het schrijven 89 landen); een onbekende landcode keur je af, ook als MOD-97 toevallig 1 oplevert.
  • Testnummers passeren alsnog. De eerder genoemde NL91ABNA0417164300 is het Nederlandse voorbeeld uit het SWIFT IBAN-register en staat in talloze tutorials. Het nummer is technisch geldig; of er een echte rekening achter zit, kan geen validator zien. Onze generator maakt willekeurige IBAN's met geldige controlecijfers. Ook die kunnen toevallig bestaan, dus gebruik ze alleen in testomgevingen.

8. Bronnen

  • ISO/IEC 7064:2003 — Information technology — Security techniques — Check character systems. Definieert de MOD-97-10 algoritmen.
  • ISO 13616-1:2020 — Financial services — International bank account number (IBAN) — Part 1: Structure of the IBAN. Lengte en opbouw per land.
  • SWIFT IBAN Registry — actueel overzicht van landen met IBAN-implementatie.
  • European Committee for Banking Standards (ECBS) — TR 201, IBAN: Standard Implementation Guidelines (historisch document).

Gerelateerde tools