IBAN-generator och valideringsverktyg - Testa bankdata

Q: Hur fungerar IBAN-validering egentligen?

Validatorn kör fyra kontroller i följd: Landskod: Är det en erkänd tvåstavig kod? Längd: Matchar den den krävda längden för det landet? (Tyskland = 22, UK = 22, Frankrike = 27, etc.) Teckentyper: Är bokstäver och siffror på rätt positioner baserat på landets format? MOD 97-kontroll: Är den matematiska checksumman lika med 1 enligt ISO 7064? Om någon kontroll misslyckas visas ett specifikt felmeddelande som förklarar vad som är fel.

Q: Varför kan ett korrekt formaterat IBAN misslyckas med validering?

Vanligaste orsakerna: Felaktiga kontrollsiffror: Även en felaktig siffra misslyckas MOD 97-testet Skrivfel: Omkastade tecken eller felaktiga siffror någonstans i IBAN Fel längd: Saknade eller extra tecken för det landet Ogiltiga tecken: Bokstäver där endast siffror är tillåtna, eller vice versa Ej stött land: Landskoden finns men är inte i vår stödda lista Felmeddelandet kommer att berätta specifikt vad som är fel.

IBAN Generator och Validator Verktyg

Vad detta verktyg gör

Testar du finansiell programvara utan riktiga bankkontodata? Du behöver giltiga IBAN-format som klarar valideringskontroller. Detta verktyg genererar slumpmässiga IBAN som följer landsspecifika format och validerar befintliga med hjälp av ISO 13616-standarden.

Här är det praktiska problemet det löser: när du bygger betalsystem eller bankapplikationer behöver du testdata som inte misslyckas med validering men inte riskerar att exponera riktiga kontonummer. Ett vanligt misstag utvecklare gör är att skapa "falska" IBAN som inte klarar MOD 97-checkalgoritmens kontroll, vilket får tester att misslyckas av fel anledningar.

Verktyget hanterar två kärnuppgifter:

Generator: Skapar strukturellt giltiga IBAN för alla länder som stöds. Varje genererat nummer klarar samma valideringskontroller som ditt produktionssystem kommer att köra.
Validator: Verifierar IBAN-struktur, kontrollsiffror och landsspecifik formatering. Användbart för att felsöka varför en IBAN blir nekad.

IBAN (International Bank Account Numbers) standardiserar hur banker identifierar konton över gränser. Varje IBAN innehåller en landskod, två kontrollsiffror beräknade via MOD 97, och ett Basic Bank Account Number (BBAN) som varierar beroende på land. Det komplexa är att Tyskland använder 22 tecken medan Frankrike behöver 27, och den interna strukturen skiljer sig helt.

Hur IBANs fungerar

IBAN-struktur och format

IBANs kan vara upp till 34 alfanumeriska tecken, även om de flesta europeiska länder använder 22-27. Varje IBAN är uppdelad i tre delar:

Landskod: Två bokstäver från ISO 3166-1 alpha-2 standarden (DE för Tyskland, GB för Förenade kungariket)
Kontrollsiffror: Två beräknade siffror som validerar hela IBAN:en med MOD 97
Grundläggande bankkonto (BBAN): Den landsspecifika delen som innehåller:
- Bankidentifierare (ibland kallad routingnummer eller bankkod)
- Filialidentifierare (UK kallar detta för sortkod)
- Kontonummer
- Ibland ytterligare nationella kontrollsiffror

Ta en tysk IBAN som exempel. Mönstret DE2!n8!n10!n betyder:

DE = landskod
2!n = två numeriska kontrollsiffror
8!n = åtta siffrors bankkod (Bankleitzahl)
10!n = tio siffrors kontonummer (Kontonummer)

Det som överraskar folk är hur mycket dessa format varierar mellan länder:

Land	Längd	Struktur	Exempel
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
Spanien (ES)	24	ES2!n4!n4!n1!n1!n10!n	ES9121000418450200051332
Italien (IT)	27	IT2!n1!a5!n5!n12!c	IT60X0542811101000000123456

IBAN Validerings Algoritm

IBAN-validering förlitar sig på MOD 97-algoritmen definierad i ISO 7064. Här är vad som faktiskt händer när du validerar en IBAN:

Flytta de första fyra tecknen (landskod och kontrollsiffror) till slutet
Ersätt varje bokstav med siffror: A=10, B=11, genom Z=35
Beräkna modulo 97 av den resulterande siffersträngen
Giltiga IBANs producerar alltid en återstod på exakt 1

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

Varför just MOD 97? Den fångar nästan alla vanliga fel: enstaka siffermisstag, omkastade siffror, till och med de flesta skrivfel som involverar liknande tecken. I praktiken har jag funnit att den fångar ungefär 99,9% av oavsiktliga dataregistreringsfel, vilket är anledningen till att den blev internationell standard.

En detalj värd att känna till: när man genererar IBANs, beräknar man kontrollsiffrorna genom att börja med "00", köra algoritmen, och sedan använda 98 minus resten. Detta säkerställer att den slutliga IBAN:en kommer att valideras korrekt.

Verktygets funktioner

IBAN-generator

Generera test-IBANs som klarar validering utan att använda riktiga kontonummer:

Landsval: Stöder 10 större europeiska länder (Tyskland, UK, Frankrike, Spanien, Italien, Nederländerna, Schweiz, Österrike, Belgien, Polen)
Formatefterlevnad: Varje genererad IBAN matchar den officiella landsstrukturen och klarar MOD 97-validering
Generering med ett klick: Ingen konfiguration krävs—välj bara ett land och generera
Kopiera till urklipp: Ett enda klick kopierar hela IBAN:en för inklistring i dina tester
Visuell uppdelning: Färgkodad visning visar landskod, kontrollsiffror och bankdetaljer separat

Genereringsprocessen:

Väljer landsspecifik formatmall
Fyller slumpmässiga siffror/bokstäver i BBAN-delen
Beräknar kontrollsiffror med MOD 97
Sammanställer och validerar den kompletta IBAN:en

Proffstips: När du seedar testdatabaser, generera IBANs från flera länder för att testa gränsöverskridande scenarier. Riktiga betalsystem har ofta kantfall med specifika länder.

IBAN-validator

Verifiera IBAN-struktur och fånga formateringsproblem innan de når produktionen:

Formatverifiering: Kontrollerar landsspecifika längd- och strukturkrav
MOD 97-validering: Kör den fullständiga kontrollsifferalgoritmen
Komponentuppdelning: Visar exakt hur IBAN:en delas upp i landskod, kontrollsiffror, bankkod och kontonummer
Specifika felmeddelanden: Istället för generiska "ogiltig"-meddelanden får du veta exakt vad som är fel
Autoformatering: Hanterar IBANs med eller utan mellanslag—formatering sker automatiskt

Valideringskontroller körs i ordning:

Landskodidentifiering (stöds den?)
Längdverifiering (rätt antal tecken för landet?)
Teckentypvalidering (siffror där förväntat, bokstäver där tillåtet)
MOD 97 kontrollsifferberäkning (fungerar matematiken?)

Vanligt scenario: Din API tar emot en IBAN från användarinput med inkonsekvent mellanslag. Använd validatorn för att normalisera den innan bearbetning—den tar automatiskt bort mellanslag och visar dig rätt format.

Steg-för-steg-guide

Generera ett IBAN

Öppna generatorfliket: Klicka på fliken "Generator" (vald som standard)
Välj ett land: Välj önskat land från rullgardinsmenyn
Generera IBAN: Klicka på knappen "Generera IBAN"
Visa resultatet: Det genererade IBAN:et visas nedan med en visuell uppdelning av dess komponenter
Kopiera till urklipp: Klicka på knappen "Kopiera till urklipp" för att kopiera IBAN:et för användning någon annanstans

Validera ett IBAN

Öppna validatorfliket: Klicka på fliken "Validator"
Ange ett IBAN: Skriv eller klistra in ett IBAN i inmatningsfältet
- Mellanslag och formatering hanteras automatiskt
- Verktyget accepterar både formaterade (med mellanslag) och oformaterade IBAN
Visa valideringsresultat: Verktyget validerar automatiskt IBAN:et medan du skriver
Kontrollera detaljerna: För giltiga IBAN visas en uppdelning av komponenterna
Granska eventuella fel: För ogiltiga IBAN visas specifika felmeddelanden som hjälper till att identifiera problemet

Användningsfall och verkliga tillämpningar

Mjukvaruutveckling och testning

API-testning: När du bygger betalningsintegrationstester behöver du IBAN-nummer som klarar validering men inte utlöser riktiga transaktioner. Generera en batch testIBAN för din automatiserade testserie och säkerställ att din felhantering fungerar korrekt för olika landsformat.

Formulärvalidering: Testar ett utcheckningsflöde? Använd validatorn för att verifiera att din frontend-validering matchar backend-krav. Ett vanligt problem är att acceptera ett IBAN-format som din betalningsleverantör senare kommer att avvisa—att fånga detta under utvecklingen sparar kundfrustration.

Gränsfallstestning: De flesta utvecklare testar med ett eller två landsformat. Vad händer när en schweizisk kund med ett 21-tecken långt IBAN använder ditt system som är designat för tyska 22-tecken långa IBAN? Generera olika landsformat för att stressa-testa dina fältlängder och valideringslogik.

Regressionstest: Efter att ha uppdaterat ditt IBAN-valideringsbibliotek, kör genererade testIBAN genom både gamla och nya versioner. Eventuella avvikelser indikerar förändringar som kan påverka produktionen.

Utveckling av finansiella applikationer

Betalsystem: När du bygger funktionalitet för internationella banköverföringar stöter du på scenarier där IBAN-strukturen själv avgör routningsbeteendet. Testa IBAN från Nederländerna (som inkluderar bokstäver i BBAN) avslöjar buggar som helt numeriska tyska IBAN inte skulle fånga.

Bankprogramvara: Att tolka IBAN för att extrahera bankkoder och filialidentifierare kräver landsspecifik logik. Generera IBAN för varje supportat land för att verifiera att din tolkningsalgoritm korrekt identifierar dessa komponenter.

Efterlevnadsverifiering: Finansiella föreskrifter kräver ofta validering av IBAN innan behandling. Använd detta verktyg för att skapa testfall som bevisar att ditt system avvisar ogiltiga kontrollsiffror och felaktiga format—väsentligt för granskningsloggar.

Utbildning och dokumentation

Utbildning i bankstandarder: Studenter som lär sig om internationella betalsystem har nytta av att se riktiga IBAN-strukturer. Generera exempel från flera länder för att illustrera hur standardisering fungerar över olika banksystem.

API-dokumentation: Istället för att använda potentiellt riktiga IBAN i din tekniska dokumentation, generera rena exempel. Dokumentation med fraser som "Använd IBAN DE89370400440532013000 för testning" berättar omedelbart för utvecklare att detta är säkra testvärden.

Dataoperationer

Databasseeding: Utvecklings- och stagingmiljöer behöver realistiska testdata. Generera olika IBAN för att befolka din databas med representativa internationella kundprofiler utan integritetsproblem.

Dataanonymisering: Migrera från produktion till staging? Ersätt riktiga IBAN med genererade som bibehåller formatvaliditet för testning samtidigt som känslig information tas bort. Kritiskt för GDPR-efterlevnad i utvecklingsmiljöer.

Alternativ och när man ska använda dem

Olika verktyg passar olika behov. Här är en ärlig jämförelse:

Kommersiella bankAPIs (t.ex. Stripe, Adyen)

Bäst för produktionsvalidering mot riktiga bankregister. Dessa tjänster kontrollerar om ett IBAN motsvarar ett faktiskt aktivt konto, inte bara om formatet är korrekt.

Använd när: Du behöver verifiera att ett IBAN existerar och kan ta emot betalningar, inte bara att det är strukturellt giltigt.

Begränsningar: Kostar pengar (vanligtvis prissättning per API-anrop), kräver integrationsarbete, och du behöver fortfarande test-IBANs för utveckling—vilket är där detta verktyg kommer in.

Programbibliotek (ibantools, iban.js, python-stdnum)

Bäst för inbäddad validering i din applikationskod. Bibliotek som ibantools för JavaScript eller python-stdnum för Python tillhandahåller både validerings- och genereringsfunktioner.

Använd när: Du behöver programmatisk åtkomst som en del av din bygg- eller körningsvalidering.

Begränsningar: Kräver utvecklingsinsats för integration, och du behöver fortfarande ett snabbt sätt att manuellt testa specifika IBANs under felsökning. Där är ett webbverktyg snabbare än att skriva testskript.

SWIFT IBAN-register

Det officiella IBAN-registret som underhålls av SWIFT listar alla landsformat och valideringsregler. Det är den auktoritativa källan.

Använd när: Du implementerar IBAN-stöd från grunden och behöver de officiella specifikationerna.

Begränsningar: Det är dokumentation, inte ett verktyg. Du skulle fortfarande behöva bygga eller hitta något för att faktiskt generera och validera IBANs baserat på dessa specifikationer.

Officiella bankvaliderare

Många nationella banker tillhandahåller landsspecifika validerare (t.ex. Bundesbank för tyska IBANs). Dessa är mycket exakta för sitt specifika land.

Använd när: Du bara arbetar med ett land och behöver valideringsdetaljer på banknivå.

Begränsningar: Fokus på ett enda land. Om du bygger internationella betalsystem skulle du behöva validerare för varje land.

När detta verktyg är meningsfullt

Använd detta verktyg när du behöver snabb testning utan API-integration. Det är särskilt användbart under utveckling och felsökning när du behöver generera giltiga testdata omedelbart eller verifiera varför ett specifikt IBAN misslyckas med validering. Det kommer inte att ersätta produktionsklara valideringsbibliotek i din kodbas, men det är snabbare än att skriva engångstestskript.

Vanliga frågor

Vad är ett IBAN och varför är det viktigt?

IBAN står för International Bank Account Number—ett standardiserat format skapat av International Organization for Standardization (ISO) för att minska fel vid gränsöverskridande betalningar. Innan IBANs använde varje land sitt eget kontonummerformat, vilket ledde till frekventa misstag och misslyckade överföringar. IBANs lägger till landskoder och kontrollsiffror för att fånga upp fel innan pengar överförs.

Hur korrekta är de genererade IBANs?

Genererade IBANs är matematiskt korrekta och klarar MOD 97-valideringsalgoritmen definierad i ISO 13616. De följer korrekta landsspecifika strukturer. Dock är de slumpmässigt skapade och motsvarar inte riktiga bankkonton—det är poängen. De är säkra för testning just därför att de inte av misstag kommer att träffa ett riktigt konto.

Vilka länder stöder denna tjänst?

För närvarande 10 europeiska länder: Tyskland, Förenade kungariket, Frankrike, Spanien, Italien, Nederländerna, Schweiz, Österrike, Belgien och Polen. Dessa täcker de vanligaste IBAN-formaten du kommer att stöta på i europeiska betalsystem. Behöver du ett annat land? Feedbackformuläret är det bästa sättet att begära tillägg.

Kan jag använda genererade IBANs för faktiska penningöverföringar?

Absolut inte. Detta är endast test-IBANs. De klarar formatvalidering men är inte kopplade till riktiga bankkonton. Att använda dem för faktiska transaktioner kommer att resultera i betalningsfel eller avvisningar. De är avsedda för utveckling, testning och utbildningsändamål.

Hur fungerar IBAN-validering egentligen?

Validatorn kör fyra kontroller i följd:

Landskod: Är det en erkänd tvåstavig kod?
Längd: Matchar den den krävda längden för det landet? (Tyskland = 22, UK = 22, Frankrike = 27, etc.)
Teckentyper: Är bokstäver och siffror på rätt positioner baserat på landets format?
MOD 97-kontroll: Är den matematiska checksumman lika med 1 enligt ISO 7064?

Om någon kontroll misslyckas visas ett specifikt felmeddelande som förklarar vad som är fel.

Spelar mellanslag någon roll i IBANs?

Inte för validering. IBANs visas vanligtvis med mellanslag (grupper om fyra) för läsbarhet, men mellanstegen är kosmetiska. DE89 3704 0044 0532 0130 00 och DE89370400440532013000 är identiska för valideringsändamål. Verktyget hanterar båda formaten automatiskt.

Skickas mina data till en server eller lagras någonstans?

Nej. Allt körs i din webbläsare med JavaScript. Ingen IBAN-data lämnar din maskin, vidrör en server eller lagras någonstans. Du kan verifiera detta genom att öppna webbläsarens utvecklarverktyg och titta på nätverksfliken—du kommer att se inga förfrågningar när du genererar eller validerar IBANs.

Vad händer om jag behöver validera ett IBAN från ett land som inte finns med?

Verktyget stöder för närvarande endast de 10 länderna i rullgardinsmenyn. Att lägga till fler kräver implementering av varje lands specifika formatregler. Om du behöver validering för länder som Norge, Sverige eller andra, meddela oss via feedbackformuläret—vi prioriterar tillägg baserat på efterfrågan.

Varför kan ett korrekt formaterat IBAN misslyckas med validering?

Vanligaste orsakerna:

Felaktiga kontrollsiffror: Även en felaktig siffra misslyckas MOD 97-testet
Skrivfel: Omkastade tecken eller felaktiga siffror någonstans i IBAN
Fel längd: Saknade eller extra tecken för det landet
Ogiltiga tecken: Bokstäver där endast siffror är tillåtna, eller vice versa
Ej stött land: Landskoden finns men är inte i vår stödda lista

Felmeddelandet kommer att berätta specifikt vad som är fel.

Hur kan jag rapportera buggar eller begära funktioner?

Använd feedbackformuläret längst ner på sidan. Specifika buggrapporter med exempel-IBANs är mest användbara. För funktionsförfrågningar hjälper det att förklara ditt användningsfall för att prioritera vad som ska byggas härnäst.

Vad är skillnaden mellan IBAN och SWIFT/BIC-koder?

IBANs identifierar specifika bankkonton, medan SWIFT/BIC-koder identifierar banker eller bankkontor. Tänk så här: SWIFT-koden talar om vilken bank, IBAN talar om vilket konto på den banken. För internationella överföringar behöver du ofta båda—SWIFT-koden dirigerar till rätt bank, sedan dirigerar IBAN till det specifika kontot.

Kan jag validera ett IBAN utan att känna till landet?

Ja, eftersom de första två bokstäverna i varje IBAN är landskoden. Validatorn läser dessa första två tecken för att avgöra vilket landsformat som ska tillämpas. Detta är varför landsidentifiering sker automatiskt när du klistrar in ett IBAN—ingen manuell landsval krävs.

Finns det IBAN-format för länder utanför Europa?

Ja, men färre. Även om IBAN ursprungligen kom från Europa och har högst antagande där, har länder som Saudiarabien, UAE, Brasilien och andra antagit det. Detta verktyg fokuserar för närvarande på europeiska format eftersom de representerar den absoluta majoriteten av gränsöverskridande transaktioner. SWIFT IBAN-registret upprätthåller den fullständiga listan.

Hur man läser och avkodar ett IBAN

Har du någonsin tittat på ett IBAN som DE89370400440532013000 och undrat vad varje del betyder? Här är hur du avkodar vilket IBAN som helst:

Steg 1: Landskod (Första 2 tecken)

DE = Tyskland
Berättar vilka formatregler som gäller för landet

Steg 2: Kontrollsiffror (Nästa 2 tecken)

89 = beräknad kontrollsumma
Dessa siffror verifierar att hela IBAN är giltigt med MOD 97

Steg 3: Bankkod (Varierar beroende på land)

37040044 i tyska IBANs = 8-siffrig bankidentifierare
Olika länder använder olika längder (UK använder 4 tecken)

Steg 4: Kontonummer (Återstående tecken)

0532013000 = det faktiska kontonumret på den banken
Längd och format beror på landet

Olika länder organiserar BBAN-delen olika. Brittiska IBANs inkluderar en 6-siffrig sortimentskod (filialidentifierare) mellan bankkoden och kontonumret. Franska IBANs kombinerar bankkod, filialkod och kontonummer med en kontrollnyckel. Att förstå dessa skillnader är avgörande när man analyserar IBANs programmatiskt.

Vanliga IBAN-valideringsfel och hur man åtgärdar dem

När du implementerar IBAN-validering kommer du upprepade gånger att stöta på dessa problem:

"Ogiltiga kontrollsiffror" Fel

Orsak: MOD 97-beräkningen är inte lika med 1. Antingen är kontrollsiffrorna felaktiga, eller så finns det ett fel någon annanstans i IBAN.

Åtgärd: Kör valideringen igen efter att ha korrigerat eventuella stavfel. Även ett enda felaktigt tecken någonstans i IBAN orsakar kontrollsifferfel. Detta är avsiktligt—det fångar upp dataregistreringsfel.

"Felaktig längd för land" Fel

Orsak: IBAN har för många eller för få tecken för sin landskod.

Åtgärd: Verifiera att landskoden matchar det avsedda landet. Tyska IBANs är alltid 22 tecken, brittiska IBANs är 22, franska är 27. Saknade eller extra tecken indikerar trunkering eller felaktiga data.

"Ogiltiga tecken" Fel

Orsak: Tecken som inte bör förekomma på den positionen—som bokstäver där endast siffror är tillåtna.

Åtgärd: Kontrollera landspecifikt format. Till exempel är tyska IBANs helt numeriska efter landskoden och kontrollsiffrorna, medan brittiska IBANs inkluderar 4 bokstäver för bankkoden.

"Ej stödd landskod" Fel

Orsak: De första två bokstäverna är ingen erkänd landskod, eller stöds inte av din validator.

Åtgärd: Verifiera stavningen av landskoden. Vanliga misstag inkluderar att använda UK istället för GB, eller EN istället för landskoder. Detta verktyg stöder 10 europeiska länder; produktionsvalidatorer bör stödja alla SWIFT-registrets länder.

Format vs. Kontoexistens

Viktig distinktion: validering bekräftar att en IBAN är strukturellt korrekt, inte att kontot existerar. En IBAN kan klara alla valideringskontroller men ändå inte motsvara ett riktigt bankkonto. För produktionsbetalningssystem behöver du ytterligare verifiering utöver formatvalidering.

Teknisk implementering för utvecklare

Om du bygger IBAN-stöd i din applikation, här är beprövade kodexempel på flera språk. Dessa implementationer hanterar de gränsfall du kommer att stöta på i produktionen:

IBAN-validering

1function validateIban(iban) {
2  // Ta bort mellanslag och konvertera till versaler
3  const cleanedIban = iban.replace(/\s/g, '').toUpperCase();
4  
5  // Kontrollera grundläggande format
6  if (!/^[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}$/.test(cleanedIban)) {
7    return false;
8  }
9  
10  // Flytta om och konvertera bokstäver till siffror
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  // Beräkna 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// Exempel på användning
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 (ogiltiga kontrollsiffror)
32

1def validate_iban(iban):
2    # Ta bort mellanslag och konvertera till versaler
3    iban = iban.replace(' ', '').upper()
4    
5    # Grundläggande formatkontroll
6    if not (len(iban) > 4 and iban[:2].isalpha() and iban[2:4].isdigit()):
7        return False
8    
9    # Flytta de första 4 tecknen till slutet
10    rearranged = iban[4:] + iban[:4]
11    
12    # Konvertera bokstäver till siffror (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    # Kontrollera om mod 97 är lika med 1
21    return int(converted) % 97 == 1
22
23# Exempel på användning
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 (ogiltiga kontrollsiffror)
27

1public class IbanValidator {
2    public static boolean validateIban(String iban) {
3        // Ta bort mellanslag och konvertera till versaler
4        String cleanedIban = iban.replaceAll("\\s", "").toUpperCase();
5        
6        // Grundläggande formatkontroll
7        if (!cleanedIban.matches("[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}")) {
8            return false;
9        }
10        
11        // Flytta de första 4 tecknen till slutet
12        String rearranged = cleanedIban.substring(4) + cleanedIban.substring(0, 4);
13        
14        // Konvertera bokstäver till siffror
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        // Beräkna 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    // Lägg till fler länder efter behov
7  };
8  
9  if (!countryFormats[countryCode]) {
10    throw new Error(`Landskod ${countryCode} stöds inte`);
11  }
12  
13  // Generera slumpmässig BBAN baserat på landsformat
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      // Generera numeriska tecken
24      for (let j = 0; j < count; j++) {
25        bban += Math.floor(Math.random() * 10);
26      }
27    } else if (type === 'a') {
28      // Generera alfabetiska tecken
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      // Generera alfanumeriska tecken
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  // Beräkna kontrollsiffror
48  const checkDigits = calculateCheckDigits(countryCode, bban);
49  
50  return countryCode + checkDigits + bban;
51}
52
53function calculateCheckDigits(countryCode, bban) {
54  // Skapa initial IBAN med '00' som kontrollsiffror
55  const initialIban = countryCode + '00' + bban;
56  
57  // Flytta om och konvertera bokstäver till siffror
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  // Beräkna 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// Exempel på användning
77console.log(generateIban('DE')); // Genererar en giltig tysk IBAN
78console.log(generateIban('GB')); // Genererar en giltig brittisk 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        # Lägg till fler länder efter behov
10    }
11    
12    if country_code not in country_formats:
13        raise ValueError(f"Landskod {country_code} stöds inte")
14    
15    # Generera slumpmässig BBAN baserat 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    # Beräkna kontrollsiffror
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    # Skapa sträng för beräkning av kontrollsiffror
40    check_string = bban + country_code + '00'
41    
42    # Konvertera bokstäver till siffror (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    # Beräkna 98 minus mod 97
51    remainder = int(numeric) % 97
52    check_digits = str(98 - remainder).zfill(2)
53    
54    return check_digits
55
56# Exempel på användning
57print(generate_iban('DE'))  # Genererar en giltig tysk IBAN
58print(generate_iban('GB'))  # Genererar en giltig brittisk IBAN
59

Referenser och vidare läsning

ISO 13616-1:2007 - Officiell IBAN-strukturspecifikation
SWIFT IBAN-register - Auktoritativ källa för landsspecifika IBAN-format
ISO 7064:2003 - MOD 97 kontrollsiffersalgoritm specifikation
Europeiska betalningsrådet - SEPA - Dokumentation för Single Euro Payments Area
Europeiska centralbanken - Betalsystem - Europeiska bankintegrationsstandarder
Bank for International Settlements - Betalsystem - Internationella betalningssystemstandarder

Börja Testa IBANs

Behöver du testdata för ditt betalsystem? Generera ett giltigt IBAN för något av de länder som stöds ovan, eller klistra in ett befintligt IBAN för att verifiera dess struktur. Verktyget körs helt i din webbläsare—inga registreringar, inga API-nycklar, ingen data skickas till servrar.

Snabbtips: Generera IBANs från flera länder för att testa gränsfallen. Riktiga betalsystem hanterar olika format, och att testa med bara ett lands format är en vanlig källa till produktionsfel.