IBAN Generator & Validator Verktøy - Test Bankdata

Q: Hvordan fungerer IBAN-validering egentlig?

Validatoren kjører fire kontroller i rekkefølge: Landkode: Er det en gjenkjent totegnskode? Lengde: Samsvarer den med den påkrevde lengden for det landet? (Tyskland = 22, UK = 22, Frankrike = 27, osv.) Tegntyper: Er bokstaver og tall i riktige posisjoner basert på landformat? MOD 97-kontroll: Tilsvarer den matematiske kontrollsummen 1 i henhold til ISO 7064? Hvis noen kontroll mislykkes, vil du se en spesifikk feilmelding som forklarer hva som er galt.

Q: Hvorfor kan en korrekt formatert IBAN mislykkes i validering?

Vanligste årsaker: Feil kontrollsifre: Selv ett feil siffer mislykkes MOD 97-testen Skrivefeil: Byttet tegn eller feil sifre hvor som helst i IBAN-en Feil lengde: Manglende eller ekstra tegn for det landet Ugyldige tegn: Bokstaver hvor bare tall er tillatt, eller omvendt Ikke støttet land: Landkoden eksisterer, men er ikke i vår støttede liste Feilmeldingen vil fortelle deg spesifikt hva som er galt.

IBAN Generator og Validator Verktøy

Hva dette verktøyet gjør

Testing av finansiell programvare uten ekte bankkontodetaljer? Du trenger gyldige IBAN-formater som passerer valideringssjekker. Dette verktøyet genererer tilfeldige IBANer som følger landspesifikke formater og validerer eksisterende ved bruk av ISO 13616-standarden.

Her er det praktiske problemet det løser: når du bygger betalingssystemer eller bankaplikasjoner, trenger du testdata som ikke vil feile validering, men heller ikke risikerer å eksponere ekte kontonumre. En vanlig feil utviklere gjør er å lage "falske" IBANer som ikke består MOD 97-sjekksumalgoritmen, noe som får tester til å feile av feil grunner.

Verktøyet håndterer to kjerneoppgaver:

Generator: Oppretter strukturelt gyldige IBANer for alle støttede land. Hvert generert nummer består de samme valideringssjekker som produksjonssystemet vil kjøre.
Validator: Verifiserer IBAN-struktur, kontrollsifre og landspesifikk formatering. Nyttig for feilsøking av hvorfor en IBAN blir avvist.

IBANer (International Bank Account Numbers) standardiserer hvordan banker identifiserer kontoer på tvers av landegrenser. Hver inneholder en landkode, to kontrollsifre beregnet via MOD 97, og et grunnleggende bankkonto-nummer (BBAN) som varierer fra land til land. Det som gjør dette komplisert er at Tyskland bruker 22 tegn mens Frankrike trenger 27, og den indre strukturen er fullstendig forskjellig.

Hvordan IBANer fungerer

IBAN-struktur og format

IBANer kan være opptil 34 alfanumeriske tegn, selv om de fleste europeiske land bruker 22-27. Hver IBAN er delt inn i tre deler:

Landkode: To bokstaver fra ISO 3166-1 alfa-2 standarden (DE for Tyskland, GB for Storbritannia)
Kontrollsifre: To beregnede sifre som validerer hele IBAN-en ved bruk av MOD 97
Grunnleggende bankkonto-nummer (BBAN): Den landsspesifikke delen som inneholder:
- Bankidentifikator (noen ganger kalt ruting-nummer eller bankkode)
- Filialidentifikator (UK kaller dette en sorteringskode)
- Kontonummer
- Noen ganger ekstra nasjonale kontrollsifre

Ta en tysk IBAN som eksempel. Mønsteret DE2!n8!n10!n betyr:

DE = landkode
2!n = to numeriske kontrollsifre
8!n = åtte-sifret bankkode (Bankleitzahl)
10!n = ti-sifret kontonummer (Kontonummer)

Det som overrasker folk er hvor mye disse formatene varierer mellom land:

Land	Lengde	Struktur	Eksempel
Tyskland (DE)	22	DE2!n8!n10!n	DE89370400440532013000
UK (GB)	22	GB2!n4!a6!n8!n	GB29NWBK60161331926819
Frankrike (FR)	27	FR2!n5!n5!n11!c2!n	FR1420041010050500013M02606
Spania (ES)	24	ES2!n4!n4!n1!n1!n10!n	ES9121000418450200051332
Italia (IT)	27	IT2!n1!a5!n5!n12!c	IT60X0542811101000000123456

IBAN Validerings-algoritme

IBAN-validering er basert på MOD 97-algoritmen definert i ISO 7064. Her er hva som faktisk skjer når du validerer en IBAN:

Flytt de første fire tegnene (landkode og kontrollsifre) til slutten
Erstatt hver bokstav med tall: A=10, B=11, opp til Z=35
Beregn modulo 97 av den resultaterende tallstrengen
Gyldige IBANer produserer alltid en rest på nøyaktig 1

Matematisk: $\text{IBAN-nummer} \bmod 97 = 1$

Hvorfor MOD 97 spesifikt? Det fanger nesten alle vanlige feil: enkelt-siffer-feil, byttet om sifre, til og med de fleste inntastingsfeil som involverer lignende tegn. I praksis har jeg funnet at det fanger omtrent 99,9% av utilsiktede dataoppføringsfeil, noe som er grunnen til at det ble den internasjonale standarden.

En særegenhet verdt å vite: ved generering av IBANer, beregner du kontrollsifrene ved å starte med "00", kjøre algoritmen, og så bruke 98 minus resten. Dette sikrer at den endelige IBAN-en vil validere korrekt.

Verktøyfunksjoner

IBAN-generator

Generer test-IBANer som passerer validering uten å bruke virkelige kontonumre:

Landsvalg: Støtter 10 store europeiske land (Tyskland, Storbritannia, Frankrike, Spania, Italia, Nederland, Sveits, Østerrike, Belgia, Polen)
Formatoverholdelse: Hver generert IBAN matcher den offisielle landstrukturen og passerer MOD 97-validering
Generering med ett klikk: Ingen konfigurasjon nødvendig—bare velg et land og generer
Kopier til utklippstavle: Ett klikk kopierer hele IBAN-en for innliming i testene dine
Visuell oversikt: Fargekodet visning viser landkode, kontrollsifre og bankdetaljer separat

Genereringsprosessen:

Velger landspesifikk formatmal
Fyller tilfeldige sifre/bokstaver i BBAN-delen
Beregner kontrollsifre ved bruk av MOD 97
Setter sammen og validerer den komplette IBAN-en

Pro-tips: Når du setter opp testdatabaser, generer IBANer fra flere land for å teste grenseoverskridende scenarioer. Reelle betalingssystemer har ofte hjørner og kanter med spesifikke land.

IBAN-validator

Bekreft IBAN-struktur og fang opp formateringsproblemer før de når produksjon:

Formatverifikasjon: Sjekker landspesifikke lengde- og strukturkrav
MOD 97-validering: Kjører den fullstendige kontrollsifre-algoritmen
Komponentoversikt: Viser nøyaktig hvordan IBAN-en deles inn i landkode, kontrollsifre, bankkode og kontonummer
Spesifikke feilmeldinger: I stedet for generiske "ugyldig"-meldinger, ser du hva som faktisk er galt
Autoformatering: Håndterer IBANer med eller uten mellomrom—formatering skjer automatisk

Valideringssjekker kjøres i rekkefølge:

Landkodegjenkjenning (er den støttet?)
Lengdeverifikasjon (riktig antall tegn for det landet?)
Tegntype-validering (tall der forventet, bokstaver der tillatt)
MOD 97 kontrollsifre-beregning (fungerer matematikken?)

Vanlig scenario: Din API mottar en IBAN fra brukerinput med inkonsistent mellomrom. Bruk validatoren til å normalisere den før behandling—den fjerner mellomrom automatisk og viser deg det riktige formatet.

Trinnvis Veiledning

Generere en IBAN

Åpne Generator-fanen: Klikk på "Generator"-fanen (valgt som standard)
Velg et Land: Velg ønsket land fra rullegardinmenyen
Generer IBAN: Klikk på "Generer IBAN"-knappen
Vis Resultat: Den genererte IBAN-en vil vises nedenfor med en visuell oversikt over dens komponenter
Kopier til Utklippstavle: Klikk på "Kopier til utklippstavle"-knappen for å kopiere IBAN-en for bruk andre steder

Validere en IBAN

Åpne Validator-fanen: Klikk på "Validator"-fanen
Skriv inn en IBAN: Skriv eller lim inn en IBAN i inndatafeltet
- Mellomrom og formatering vil bli automatisk håndtert
- Verktøyet aksepterer både formaterte (med mellomrom) og uformaterte IBAN-er
Vis Valideringsresultater: Verktøyet vil automatisk validere IBAN-en mens du skriver
Sjekk Detaljene: For gyldige IBAN-er vil en oversikt over komponentene bli vist
Gjennomgå Eventuelle Feil: For ugyldige IBAN-er vil spesifikke feilmeldinger hjelpe deg med å identifisere problemet

Bruksområder og virkelige applikasjoner

Programvareutvikling og testing

API-testing: Når du bygger betalingsintegrasjonstester, trenger du IBANer som passerer validering uten å utløse faktiske transaksjoner. Generer en batch med test-IBANer for din automatiserte testsuite, og sikre at feilhåndteringen din fungerer riktig for forskjellige landsformater.

Skjemavalidering: Tester du en betalingsflyt? Bruk validatoren for å bekrefte at frontend-validering samsvarer med backend-krav. Et hyppig problem er å akseptere et IBAN-format som betalingsleverandøren din senere vil avvise—å oppdage dette under utvikling sparer kundefrustrasjon.

Grensetilfelle-testing: De fleste utviklere tester med ett eller to landsformater. Hva skjer når en sveitsisk kunde med en 21-tegns IBAN bruker systemet ditt som er designet rundt tyske 22-tegns IBANer? Generer forskjellige landsformater for å teste felt-lengder og valideringslogikk.

Regresjonstesting: Etter å ha oppdatert IBAN-valideringsbiblioteket ditt, kjør genererte test-IBANer gjennom både gamle og nye versjoner. Eventuelle avvik indikerer endringer som kan påvirke produksjonen.

Utvikling av finansielle applikasjoner

Betalingssystemer: Når du bygger funksjonalitet for internasjonale bankoverføringer, vil du støte på scenarioer der IBAN-strukturen selv bestemmer ruting. Test-IBANer fra Nederland (som inkluderer bokstaver i BBAN) avslører feil som rent numeriske tyske IBANer ikke vil avdekke.

Bankprogramvare: Parsing av IBANer for å trekke ut bankkoder og filialidentifikatorer krever landsspesifikk logikk. Generer IBANer for hvert støttet land for å bekrefte at parsing-algoritmen din riktig identifiserer disse komponentene.

Samsvarskontroll: Finansielle forskrifter krever ofte validering av IBANer før behandling. Bruk dette verktøyet til å lage testtilfeller som beviser at systemet ditt avviser ugyldige kontrollsifre og feilaktige formater—essensielt for revisjonslogger.

Utdanning og dokumentasjon

Opplæring i bankstandarder: Studenter som lærer om internasjonale betalingssystemer, har nytte av å se virkelige IBAN-strukturer. Generer eksempler fra flere land for å illustrere hvordan standardisering fungerer på tvers av ulike banksystemer.

API-dokumentasjon: I stedet for å bruke potensielt virkelige IBANer i teknisk dokumentasjon, generer rene eksempler. Dokumentasjon med fraser som "Bruk IBAN DE89370400440532013000 for testing" forteller umiddelbart utviklere at dette er trygge testverdi.

Dataoperasjoner

Database-seeding: Utviklings- og staging-miljøer trenger realistiske testdata. Generer forskjellige IBANer for å fylle databasen med representative internasjonale kundeprofilerer uten personvernproblemer.

Data-anonymisering: Migrerer fra produksjon til staging? Erstatt virkelige IBANer med genererte som opprettholder formatgyldighet for testing mens sensitive opplysninger fjernes. Kritisk for GDPR-samsvar i utviklingsmiljøer.

Alternativer og når du bør bruke dem

Forskjellige verktøy passer til forskjellige behov. Her er en ærlig sammenligning:

Kommersielle bankers API-er (f.eks. Stripe, Adyen)

Best for produksjonsvalidering mot virkelige bankregistre. Disse tjenestene sjekker om en IBAN tilsvarer en faktisk aktiv konto, ikke bare om formatet er korrekt.

Bruk når: Du trenger å bekrefte at en IBAN eksisterer og kan motta betalinger, ikke bare at den er strukturelt gyldig.

Begrensninger: Koster penger (vanligvis pris per API-kall), krever integrasjonsarbeid, og du trenger fortsatt test-IBANer for utvikling—det er her dette verktøyet kommer inn.

Programmeringsspråk-biblioteker (ibantools, iban.js, python-stdnum)

Best for innebygd validering i din applikasjonskode. Biblioteker som ibantools for JavaScript eller python-stdnum for Python tilbyr både validerings- og genereringsfunksjoner.

Bruk når: Du trenger programmatisk tilgang som en del av bygg- eller kjøretidsvalidering.

Begrensninger: Krever utviklingsmøye for å integrere, og du trenger fortsatt en rask måte å manuelt teste spesifikke IBANer under feilsøking. Det er der et nettverktøy er raskere enn å skrive testskript.

SWIFT IBAN-register

Det offisielle IBAN-registeret vedlikeholdt av SWIFT lister alle lands formater og valideringsregler. Det er den autoritative kilden.

Bruk når: Du implementerer IBAN-støtte fra bunnen av og trenger de offisielle spesifikasjonene.

Begrensninger: Det er dokumentasjon, ikke et verktøy. Du ville fortsatt trenge å bygge eller finne noe for å faktisk generere og validere IBANer basert på disse spesifikasjonene.

Offisielle bankvalidatorer

Mange nasjonale banker tilbyr landsspesifikke validatorer (f.eks. Bundesbank for tyske IBANer). Disse er svært nøyaktige for sitt spesifikke land.

Bruk når: Du kun arbeider med ett land og trenger bank-nivå valideringsdetaljer.

Begrensninger: Fokus på ett land. Hvis du bygger internasjonale betalingssystemer, ville du trenge validatorer for hvert land.

Når dette verktøyet gir mening

Bruk dette verktøyet når du trenger rask testing uten API-integrasjon. Det er spesielt nyttig under utvikling og feilsøking når du trenger å generere gyldige testdata umiddelbart eller bekrefte hvorfor en spesifikk IBAN ikke består validering. Det vil ikke erstatte produksjonskvalitets valideringsbiblioteker i kodebasen din, men det er raskere enn å skrive midlertidige testskript.

Ofte stilte spørsmål

Hva er en IBAN og hvorfor er det viktig?

IBAN står for International Bank Account Number—et standardisert format opprettet av International Organization for Standardization (ISO) for å redusere feil ved grenseoverskridende betalinger. Før IBANer brukte hvert land sitt eget kontonummerformat, noe som førte til hyppige feil og mislykkede overføringer. IBANer legger til landkoder og kontrollsifre for å fange opp feil før penger flyttes.

Hvor nøyaktige er de genererte IBANene?

Genererte IBANer er matematisk korrekte og består MOD 97-valideringsalgoritmen definert i ISO 13616. De følger riktige landspesifikke strukturer. Imidlertid er de tilfeldig opprettet og svarer ikke til virkelige bankkontoer—det er poenget. De er trygge for testing nettopp fordi de ikke ved et uhell vil treffe en virkelig konto.

Hvilke land støtter denne verktøyet?

For øyeblikket 10 europeiske land: Tyskland, Storbritannia, Frankrike, Spania, Italia, Nederland, Sveits, Østerrike, Belgia og Polen. Disse dekker de vanligste IBAN-formatene du vil støte på i europeiske betalingssystemer. Trenger du et annet land? Tilbakemeldingsskjemaet er den beste måten å be om tillegg.

Kan jeg bruke genererte IBANer for faktiske pengeoverføringer?

Absolutt ikke. Dette er kun test-IBANer. De består formatvalidering, men er ikke koblet til virkelige bankkontoer. Bruk av dem for faktiske transaksjoner vil resultere i betalingssvikt eller avvisninger. De er ment for utvikling, testing og opplæringsformål.

Hvordan fungerer IBAN-validering egentlig?

Validatoren kjører fire kontroller i rekkefølge:

Landkode: Er det en gjenkjent totegnskode?
Lengde: Samsvarer den med den påkrevde lengden for det landet? (Tyskland = 22, UK = 22, Frankrike = 27, osv.)
Tegntyper: Er bokstaver og tall i riktige posisjoner basert på landformat?
MOD 97-kontroll: Tilsvarer den matematiske kontrollsummen 1 i henhold til ISO 7064?

Hvis noen kontroll mislykkes, vil du se en spesifikk feilmelding som forklarer hva som er galt.

Betyr mellomrom noe i IBANer?

Ikke for validering. IBANer vises vanligvis med mellomrom (grupper på fire) for lesbarhet, men mellomrommene er kosmetiske. DE89 3704 0044 0532 0130 00 og DE89370400440532013000 er identiske for valideringsformål. Verktøyet håndterer begge formater automatisk.

Sendes dataene mine til en server eller lagres de noe sted?

Nei. Alt kjøres i nettleseren ved hjelp av JavaScript. Ingen IBAN-data forlater maskinen din, berører en server eller lagres noe sted. Du kan bekrefte dette ved å åpne nettleserens utviklingsverktøy og se på nettverksfanen—du vil ikke se noen forespørsler når du genererer eller validerer IBANer.

Hva hvis jeg trenger å validere en IBAN fra et land som ikke er oppført?

Verktøyet støtter for øyeblikket bare de 10 landene i rullegardinmenyen. Å legge til flere krever implementering av hvert lands spesifikke formatregler. Hvis du trenger validering for land som Norge, Sverige eller andre, gi oss beskjed via tilbakemeldingsskjemaet—vi prioriterer tillegg basert på etterspørsel.

Hvorfor kan en korrekt formatert IBAN mislykkes i validering?

Vanligste årsaker:

Feil kontrollsifre: Selv ett feil siffer mislykkes MOD 97-testen
Skrivefeil: Byttet tegn eller feil sifre hvor som helst i IBAN-en
Feil lengde: Manglende eller ekstra tegn for det landet
Ugyldige tegn: Bokstaver hvor bare tall er tillatt, eller omvendt
Ikke støttet land: Landkoden eksisterer, men er ikke i vår støttede liste

Feilmeldingen vil fortelle deg spesifikt hva som er galt.

Hvordan kan jeg rapportere feil eller be om funksjoner?

Bruk tilbakemeldingsskjemaet nederst på siden. Spesifikke feilrapporter med eksempel-IBANer er mest nyttige. For funksjonsforespørsler hjelper det å forklare bruksområdet ditt for å prioritere hva som bygges videre.

Hva er forskjellen mellom IBAN og SWIFT/BIC-koder?

IBANer identifiserer spesifikke bankkontoer, mens SWIFT/BIC-koder identifiserer banker eller bankfilialer. Tenk på det slik: SWIFT-koden forteller deg hvilken bank, IBAN-en forteller deg hvilken konto på den banken. For internasjonale overføringer trenger du ofte begge—SWIFT-koden ruter til riktig bank, så IBAN-en ruter til den spesifikke kontoen.

Kan jeg validere en IBAN uten å kjenne landet?

Ja, fordi de første to bokstavene i enhver IBAN er landkoden. Validatoren leser disse første to tegnene for å bestemme hvilket landformat som skal brukes. Dette er hvorfor landdeteksjon skjer automatisk når du limer inn en IBAN—du trenger ikke å velge landet manuelt.

Finnes det IBAN-formater for land utenfor Europa?

Ja, men færre. Selv om IBAN oppsto i Europa og har høyest utbredelse der, har land som Saudi-Arabia, UAE, Brasil og andre tatt det i bruk. Dette verktøyet fokuserer for øyeblikket på europeiske formater da de representerer det store flertallet av grenseoverskridende transaksjoner. SWIFT IBAN-registeret vedlikeholder den fullstendige listen.

Hvordan lese og dekode en IBAN

Har du noen gang sett en IBAN som DE89370400440532013000 og lurt på hva hver del betyr? Her er hvordan du kan dekode enhver IBAN:

Trinn 1: Landkode (Første 2 tegn)

DE = Tyskland
Forteller deg hvilke formatregler som gjelder for landet

Trinn 2: Kontrollsifre (Neste 2 tegn)

89 = beregnet kontrollsum
Disse sifrene bekrefter at hele IBAN-en er gyldig ved bruk av MOD 97

Trinn 3: Bankkode (Varierer etter land)

37040044 i tyske IBANer = 8-sifret bankidentifikator
Forskjellige land bruker forskjellige lengder (UK bruker 4 tegn)

Trinn 4: Kontonummer (Gjenværende tegn)

0532013000 = det faktiske kontonummeret i den banken
Lengde og format avhenger av landet

Forskjellige land organiserer BBAN-delen ulikt. UK IBANer inkluderer en 6-sifret sortskode (filialidentifikator) mellom bankkoden og kontonummeret. Franske IBANer kombinerer bankkode, filialkode og kontonummer med en kontrollnøkkel. Å forstå disse forskjellene er avgjørende når man analyserer IBANer programmatisk.

Vanlige IBAN-valideringsfeil og hvordan fikse dem

Når du implementerer IBAN-validering, vil du støte på disse problemene gjentatte ganger:

"Ugyldige kontrollsifre" Feil

Årsak: MOD 97-beregningen er ikke lik 1. Enten er kontrollsifre feil, eller det er en feil et annet sted i IBAN.

Løsning: Kjør valideringen på nytt etter å ha korrigert eventuelle skrivefeil. Selv ett feil tegn hvor som helst i IBAN-en fører til kontrollsifferfeil. Dette er med vilje—det fanger opp dataregistreringsfeil.

"Feil lengde for land" Feil

Årsak: IBAN-en har for mange eller for få tegn for sin landkode.

Løsning: Bekreft at landkoden matcher det tiltenkte landet. Tyske IBANer er alltid 22 tegn, UK IBANer er 22, franske er 27. Manglende eller ekstra tegn indikerer avkorting eller feil data.

"Ugyldige tegn" Feil

Årsak: Tegn som ikke skal være på den posisjonen—som bokstaver der bare tall er tillatt.

Løsning: Sjekk landspesifikk format. For eksempel er tyske IBANer helt numeriske etter landkode og kontrollsifre, mens UK IBANer inkluderer 4 bokstaver for bankkoden.

"Ikke støttet landkode" Feil

Årsak: De første to bokstavene er ikke en gjenkjent landkode, eller de støttes ikke av din validator.

Løsning: Bekreft stavemåten til landkoden. Vanlige feil inkluderer å bruke UK i stedet for GB, eller EN i stedet for landkoder. Dette verktøyet støtter 10 europeiske land; produksjonsvalidatorer bør støtte alle SWIFT-registerlandene.

Format vs. Kontoeksistens

Viktig distinksjon: validering bekrefter at en IBAN er strukturelt korrekt, ikke at kontoen eksisterer. En IBAN kan bestå alle valideringssjekker, men likevel ikke tilsvare en virkelig bankkonto. For produksjonsbetalingssystemer trenger du ytterligere verifisering utover formatvalidering.

Teknisk implementering for utviklere

Hvis du bygger IBAN-støtte inn i applikasjonen din, her er kampbekreftede kodeeksempler i flere språk. Disse implementasjonene håndterer kanttilfellene du vil møte i produksjon:

IBAN-validering

1function validateIban(iban) {
2  // Fjern mellomrom og konverter til store bokstaver
3  const cleanedIban = iban.replace(/\s/g, '').toUpperCase();
4  
5  // Sjekk grunnleggende format
6  if (!/^[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}$/.test(cleanedIban)) {
7    return false;
8  }
9  
10  // Flytt om og konverter bokstaver til tall
11  const rearranged = cleanedIban.substring(4) + cleanedIban.substring(0, 4);
12  const converted = rearranged.split('').map(char => {
13    if (/[A-Z]/.test(char)) {
14      return (char.charCodeAt(0) - 55).toString();
15    }
16    return char;
17  }).join('');
18  
19  // Beregn mod 97
20  let remainder = 0;
21  for (let i = 0; i < converted.length; i++) {
22    remainder = (remainder * 10 + parseInt(converted[i], 10)) % 97;
23  }
24  
25  return remainder === 1;
26}
27
28// Eksempel på bruk
29console.log(validateIban('DE89 3704 0044 0532 0130 00')); // true
30console.log(validateIban('GB29 NWBK 6016 1331 9268 19')); // true
31console.log(validateIban('DE89 3704 0044 0532 0130 01')); // false (ugyldige kontrollsifre)
32

1def validate_iban(iban):
2    # Fjern mellomrom og konverter til store bokstaver
3    iban = iban.replace(' ', '').upper()
4    
5    # Grunnleggende formatsjekk
6    if not (len(iban) > 4 and iban[:2].isalpha() and iban[2:4].isdigit()):
7        return False
8    
9    # Flytt de første 4 tegnene til slutten
10    rearranged = iban[4:] + iban[:4]
11    
12    # Konverter bokstaver til tall (A=10, B=11, ..., Z=35)
13    converted = ''
14    for char in rearranged:
15        if char.isalpha():
16            converted += str(ord(char) - 55)
17        else:
18            converted += char
19    
20    # Sjekk om mod 97 er lik 1
21    return int(converted) % 97 == 1
22
23# Eksempel på bruk
24print(validate_iban('DE89 3704 0044 0532 0130 00'))  # True
25print(validate_iban('GB29 NWBK 6016 1331 9268 19'))  # True
26print(validate_iban('DE89 3704 0044 0532 0130 01'))  # False (ugyldige kontrollsifre)
27

1public class IbanValidator {
2    public static boolean validateIban(String iban) {
3        // Fjern mellomrom og konverter til store bokstaver
4        String cleanedIban = iban.replaceAll("\\s", "").toUpperCase();
5        
6        // Grunnleggende formatsjekk
7        if (!cleanedIban.matches("[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}")) {
8            return false;
9        }
10        
11        // Flytt de første 4 tegnene til slutten
12        String rearranged = cleanedIban.substring(4) + cleanedIban.substring(0, 4);
13        
14        // Konverter bokstaver til tall
15        StringBuilder converted = new StringBuilder();
16        for (char c : rearranged.toCharArray()) {
17            if (Character.isLetter(c)) {
18                converted.append(c - 'A' + 10);
19            } else {
20                converted.append(c);
21            }
22        }
23        
24        // Beregn mod 97
25        BigInteger numeric = new BigInteger(converted.toString());
26        return numeric.mod(BigInteger.valueOf(97)).intValue() == 1;
27    }
28    
29    public static void main(String[] args) {
30        System.out.println(validateIban("DE89 3704 0044 0532 0130 00"));  // true
31        System.out.println(validateIban("GB29 NWBK 6016 1331 9268 19"));  // true
32        System.out.println(validateIban("DE89 3704 0044 0532 0130 01"));  // false
33    }
34}
35

IBAN-generering

1function generateIban(countryCode) {
2  const countryFormats = {
3    'DE': { length: 22, bbanPattern: '8n10n' },
4    'GB': { length: 22, bbanPattern: '4a6n8n' },
5    'FR': { length: 27, bbanPattern: '5n5n11c2n' }
6    // Legg til flere land etter behov
7  };
8  
9  if (!countryFormats[countryCode]) {
10    throw new Error(`Landkode ${countryCode} støttes ikke`);
11  }
12  
13  // Generer tilfeldig BBAN basert på landmønster
14  let bban = '';
15  const pattern = countryFormats[countryCode].bbanPattern;
16  let i = 0;
17  
18  while (i < pattern.length) {
19    const count = parseInt(pattern.substring(i + 1), 10);
20    const type = pattern[i];
21    
22    if (type === 'n') {
23      // Generer numeriske tegn
24      for (let j = 0; j < count; j++) {
25        bban += Math.floor(Math.random() * 10);
26      }
27    } else if (type === 'a') {
28      // Generer alfabetiske tegn
29      for (let j = 0; j < count; j++) {
30        bban += String.fromCharCode(65 + Math.floor(Math.random() * 26));
31      }
32    } else if (type === 'c') {
33      // Generer alfanumeriske tegn
34      for (let j = 0; j < count; j++) {
35        const isLetter = Math.random() > 0.5;
36        if (isLetter) {
37          bban += String.fromCharCode(65 + Math.floor(Math.random() * 26));
38        } else {
39          bban += Math.floor(Math.random() * 10);
40        }
41      }
42    }
43    
44    i += 2;
45  }
46  
47  // Beregn kontrollsifre
48  const checkDigits = calculateCheckDigits(countryCode, bban);
49  
50  return countryCode + checkDigits + bban;
51}
52
53function calculateCheckDigits(countryCode, bban) {
54  // Opprett første IBAN med '00' som kontrollsifre
55  const initialIban = countryCode + '00' + bban;
56  
57  // Flytt om og konverter bokstaver til tall
58  const rearranged = bban + countryCode + '00';
59  const converted = rearranged.split('').map(char => {
60    if (/[A-Z]/.test(char)) {
61      return (char.charCodeAt(0) - 55).toString();
62    }
63    return char;
64  }).join('');
65  
66  // Beregn 98 minus mod 97
67  let remainder = 0;
68  for (let i = 0; i < converted.length; i++) {
69    remainder = (remainder * 10 + parseInt(converted[i], 10)) % 97;
70  }
71  
72  const checkDigits = (98 - remainder).toString().padStart(2, '0');
73  return checkDigits;
74}
75
76// Eksempel på bruk
77console.log(generateIban('DE')); // Genererer en gyldig tysk IBAN
78console.log(generateIban('GB')); // Genererer en gyldig UK IBAN
79

1import random
2import string
3
4def generate_iban(country_code):
5    country_formats = {
6        'DE': {'length': 22, 'bban_format': '8n10n'},
7        'GB': {'length': 22, 'bban_format': '4a6n8n'},
8        'FR': {'length': 27, 'bban_format': '5n5n11c2n'}
9        # Legg til flere land etter behov
10    }
11    
12    if country_code not in country_formats:
13        raise ValueError(f"Landkode {country_code} støttes ikke")
14    
15    # Generer tilfeldig BBAN basert på landsformat
16    bban = ''
17    format_str = country_formats[country_code]['bban_format']
18    i = 0
19    
20    while i < len(format_str):
21        count = int(''.join(c for c in format_str[i+1:] if c.isdigit()))
22        type_char = format_str[i]
23        
24        if type_char == 'n':  # Numerisk
25            bban += ''.join(random.choices(string.digits, k=count))
26        elif type_char == 'a':  # Alfabetisk
27            bban += ''.join(random.choices(string.ascii_uppercase, k=count))
28        elif type_char == 'c':  # Alfanumerisk
29            bban += ''.join(random.choices(string.ascii_uppercase + string.digits, k=count))
30        
31        i += 1 + len(str(count))
32    
33    # Beregn kontrollsifre
34    check_digits = calculate_check_digits(country_code, bban)
35    
36    return country_code + check_digits + bban
37
38def calculate_check_digits(country_code, bban):
39    # Opprett streng for beregning av kontrollsifre
40    check_string = bban + country_code + '00'
41    
42    # Konverter bokstaver til tall (A=10, B=11, ..., Z=35)
43    numeric = ''
44    for char in check_string:
45        if char.isalpha():
46            numeric += str(ord(char.upper()) - 55)
47        else:
48            numeric += char
49    
50    # Beregn 98 minus mod 97
51    remainder = int(numeric) % 97
52    check_digits = str(98 - remainder).zfill(2)
53    
54    return check_digits
55
56# Eksempel på bruk
57print(generate_iban('DE'))  # Genererer en gyldig tysk IBAN
58print(generate_iban('GB'))  # Genererer en gyldig UK IBAN
59

Referanser og videre lesning

ISO 13616-1:2007 - Offisiell IBAN-strukturspesifikasjon
SWIFT IBAN-register - Autoritativ kilde for landsspesifikke IBAN-formater
ISO 7064:2003 - MOD 97 kontrollsifferalgoritme-spesifikasjon
European Payments Council - SEPA - Dokumentasjon for Single Euro Payments Area
Den europeiske sentralbank - Betalingssystemer - Europeiske bankintegrasjonsstandarder
Bank for internasjonale oppgjør - Betalingssystemer - Internasjonale betalingssystemstandarder

Start Testing IBANs

Trenger du testdata for betalingssystemet ditt? Generer en gyldig IBAN for et hvilket som helst støttet land ovenfor, eller lim inn en eksisterende IBAN for å verifisere dens struktur. Verktøyet kjøres fullstendig i nettleseren din—ingen påmeldinger, ingen API-nøkler, ingen data sendt til servere.

Rask tips: Generer IBANer fra flere land for å teste grensetilfeller. Reelle betalingssystemer håndterer ulike formater, og testing med kun ett lands format er en vanlig kilde til produksjonsfeil.