Skapa slumpmässiga IBAN som följer formatet eller validera befintliga med vårt enkla verktyg. Perfekt för testning av finansiella applikationer, bankprogramvara och utbildningsändamål.
Det internationella bankkontonumret (IBAN) generator och valideringsverktyg är ett omfattande verktyg designat för testning och verifiering i finansiella applikationer, bankprogramvara och utbildningssammanhang. Denna användarvänliga applikation erbjuder två viktiga funktioner: att generera slumpmässiga men formatkompatibla IBAN och att validera den strukturella integriteten hos användarindata IBAN. Oavsett om du är en utvecklare som testar finansiell programvara, en QA-specialist som verifierar bankapplikationer eller en pedagog som förklarar internationella bankstandarder, erbjuder detta verktyg en enkel lösning utan att kräva komplexa konfigurationer eller tredjepartsintegrationer.
IBAN (International Bank Account Numbers) är standardiserade kontonummer som används internationellt för att underlätta gränsöverskridande transaktioner och minska fel vid internationella penningöverföringar. Varje IBAN består av en landskod, kontrollsiffror och ett grundläggande bankkontonummer (BBAN) som följer landspecifika format. Vårt verktyg stöder flera landsformat och säkerställer att alla genererade IBAN passerar MOD 97 valideringsalgoritmen som specificeras i ISO 13616-standarden.
Ett IBAN består av upp till 34 alfanumeriska tecken, även om den exakta längden varierar beroende på land. Den standardiserade strukturen inkluderar:
Till exempel följer ett tyskt IBAN strukturen DE2!n8!n10!n där:
DE är landskoden2!n representerar två numeriska kontrollsiffror8!n representerar en åttasiffrig bankkod10!n representerar ett tiosiffrigt kontonummerOlika länder har olika BBAN-format, vilket resulterar i varierande IBAN-längder:
| Land | Längd | Struktur | Exempel |
|---|---|---|---|
| Tyskland (DE) | 22 | DE2!n8!n10!n | DE89370400440532013000 |
| Storbritannien (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-valideringsprocessen använder MOD 97-algoritmen som specificeras i ISO 7064-standarden. Så här fungerar det:
Matematiskt representeras detta som:
Vår validerare implementerar denna algoritm för att verifiera den strukturella integriteten hos varje IBAN som användare anger.
IBAN-generatorn skapar slumpmässiga men giltiga IBAN för teständamål. Viktiga funktioner inkluderar:
Generatorn skapar IBAN genom att:
IBAN-valideraren kontrollerar den strukturella integriteten hos användarindata IBAN. Viktiga funktioner inkluderar:
Valideraren utför flera kontroller:
IBAN-generatorn och valideringsverktyget tjänar flera syften inom olika områden:
Även om vårt IBAN-generator och valideringsverktyg erbjuder en strömlinjeformad upplevelse för teständamål, finns det alternativa metoder att överväga:
Vårt verktyg fyller gapet mellan dessa alternativ genom att erbjuda ett enkelt, tillgängligt gränssnitt för både generation och validering utan att kräva teknisk integration eller betalade prenumerationer.
Ett IBAN (International Bank Account Number) är ett standardiserat internationellt nummersystem som utvecklats för att identifiera bankkonton över nationsgränser. Det etablerades av den internationella standardiseringsorganisationen (ISO) för att underlätta felfria internationella transaktioner.
IBAN-generatorn skapar strukturellt giltiga IBAN som passerar MOD 97-kontrollalgoritmen som specificeras i ISO 13616-standarden. Även om de genererade IBAN är matematiskt giltiga, är de slumpmässiga och inte kopplade till faktiska bankkonton, vilket gör dem perfekta för testning men inte för verkliga transaktioner.
Verktyget stöder för närvarande IBAN-format för Tyskland, Storbritannien, Frankrike, Spanien, Italien, Nederländerna, Schweiz, Österrike, Belgien och Polen. Dessa täcker de mest använda IBAN-formaten i Europa.
Nej. De IBAN som skapas av denna generator är strukturellt giltiga men slumpmässigt genererade. De är inte kopplade till verkliga bankkonton och bör endast användas för testning, utbildning eller demonstrationsändamål.
Valideraren kontrollerar flera aspekter av ett IBAN:
Nej. Även om IBAN ofta visas med mellanslag för läsbarhet (vanligtvis i grupper om fyra tecken), ignoreras mellanslagen under valideringen. Vårt verktyg hanterar både formaterade och oformaterade IBAN.
Nej. Detta verktyg fungerar helt i din webbläsare. Inga IBAN-data skickas till någon server, lagras eller delas med tredje part. Dina data förblir privata och säkra.
För närvarande validerar verktyget endast IBAN från de stödda länder som listas i rullgardinsmenyn. Om du behöver validering för ytterligare länder, vänligen meddela oss via feedbackformuläret.
Ett IBAN kan misslyckas med valideringen av flera skäl:
Vi välkomnar feedback för att förbättra verktyget. Vänligen använd feedbackformuläret som är tillgängligt via länken längst ner på sidan för att rapportera eventuella problem eller föreslå förbättringar.
För utvecklare som är intresserade av att implementera IBAN-validering och generation i sina egna applikationer, här är kodexempel i olika programmeringsspråk:
1function validateIban(iban) {
2 // Ta bort mellanslag och konvertera till versaler
3 const cleanedIban = iban.replace(/\s/g, '').toUpperCase();
4
5 // Kontroll av grundläggande format
6 if (!/^[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}$/.test(cleanedIban)) {
7 return false;
8 }
9
10 // Omarrangera 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// Exempelanvä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)
321def 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# Exempelanvä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)
271public 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}
351function 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 vid behov
7 };
8
9 if (!countryFormats[countryCode]) {
10 throw new Error(`Landskod ${countryCode} stöds inte`);
11 }
12
13 // Generera slumpmässigt 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 // Omarrangera 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// Exempelanvändning
77console.log(generateIban('DE')); // Genererar en giltig tysk IBAN
78console.log(generateIban('GB')); // Genererar en giltig brittisk IBAN
791import 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 vid 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ässigt 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 kontrollsifferberäkning
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# Exempelanvändning
57print(generate_iban('DE')) # Genererar en giltig tysk IBAN
58print(generate_iban('GB')) # Genererar en giltig brittisk IBAN
59IBAN-generatorn och valideringsverktyget erbjuder en enkel men kraftfull lösning för test- och utbildningsändamål relaterade till internationella bankidentifierare. Genom att erbjuda både genererings- och valideringsmöjligheter i ett användarvänligt gränssnitt eliminerar det behovet av komplexa konfigurationer eller tredjepartsintegrationer.
Oavsett om du utvecklar finansiella applikationer, testar betalningssystem eller lär dig om internationella bankstandarder, erbjuder detta verktyg ett enkelt sätt att arbeta med IBAN. Den omfattande valideringen säkerställer att alla genererade IBAN är strukturellt sunda och följer internationella standarder.
Prova att generera eller validera ett IBAN nu för att uppleva verktygets kapabiliteter på egen hand!
Upptäck fler verktyg som kan vara användbara för din arbetsflöde