Crea IBAN casuali conformi al formato o convalida quelli esistenti con il nostro semplice strumento. Perfetto per testare applicazioni finanziarie, software bancari e scopi educativi.
Lo Strumento di Generazione e Validazione dell'International Bank Account Number (IBAN) è un'applicazione completa progettata per scopi di test e verifica in applicazioni finanziarie, software bancari e contesti educativi. Questa applicazione user-friendly offre due funzionalità essenziali: generare IBAN casuali ma conformi al formato e convalidare l'integrità strutturale degli IBAN inseriti dall'utente. Che tu sia uno sviluppatore che testa software finanziario, uno specialista QA che verifica applicazioni bancarie o un educatore che spiega gli standard bancari internazionali, questo strumento fornisce una soluzione semplice senza richiedere configurazioni complesse o integrazioni di terze parti.
Gli IBAN (International Bank Account Numbers) sono identificatori di conto standardizzati utilizzati a livello internazionale per facilitare le transazioni transfrontaliere e ridurre gli errori nei trasferimenti di denaro internazionali. Ogni IBAN è composto da un codice paese, cifre di controllo e un numero di conto bancario di base (BBAN) che segue formati specifici per paese. Il nostro strumento supporta più formati nazionali e garantisce che tutti gli IBAN generati superino l'algoritmo di validazione MOD 97 specificato nello standard ISO 13616.
Un IBAN è composto da un massimo di 34 caratteri alfanumerici, anche se la lunghezza esatta varia in base al paese. La struttura standard include:
Ad esempio, un IBAN tedesco segue la struttura DE2!n8!n10!n dove:
DE è il codice paese2!n rappresenta due cifre numeriche di controllo8!n rappresenta un codice bancario di otto cifre10!n rappresenta un numero di conto di dieci cifreDiversi paesi hanno formati BBAN differenti, risultando in lunghezze IBAN variabili:
| Paese | Lunghezza | Struttura | Esempio |
|---|---|---|---|
| Germania (DE) | 22 | DE2!n8!n10!n | DE89370400440532013000 |
| Regno Unito (GB) | 22 | GB2!n4!a6!n8!n | GB29NWBK60161331926819 |
| Francia (FR) | 27 | FR2!n5!n5!n11!c2!n | FR1420041010050500013M02606 |
| Spagna (ES) | 24 | ES2!n4!n4!n1!n1!n10!n | ES9121000418450200051332 |
| Italia (IT) | 27 | IT2!n1!a5!n5!n12!c | IT60X0542811101000000123456 |
Il processo di validazione dell'IBAN utilizza l'algoritmo MOD 97 come specificato nello standard ISO 7064. Ecco come funziona:
Matematicamente, questo è rappresentato come:
Il nostro validatore implementa questo algoritmo per verificare l'integrità strutturale di qualsiasi IBAN inserito dagli utenti.
Il generatore di IBAN crea IBAN casuali ma validi per scopi di test. Le caratteristiche principali includono:
Il generatore crea IBAN seguendo questi passaggi:
Il validatore di IBAN controlla l'integrità strutturale degli IBAN inseriti dall'utente. Le caratteristiche principali includono:
Il validatore esegue più controlli:
Lo strumento Generatore e Validatore IBAN serve a più scopi in diversi ambiti:
Sebbene il nostro strumento Generatore e Validatore IBAN offra un'esperienza semplificata per scopi di test, ci sono approcci alternativi da considerare:
Il nostro strumento colma il divario tra queste alternative fornendo un'interfaccia semplice e accessibile per sia la generazione che la validazione senza richiedere integrazioni tecniche o abbonamenti a pagamento.
Un IBAN (International Bank Account Number) è un sistema di numerazione internazionale standardizzato sviluppato per identificare i conti bancari attraverso le frontiere nazionali. È stato stabilito dall'Organizzazione Internazionale per la Normazione (ISO) per facilitare transazioni internazionali senza errori.
Il generatore di IBAN crea IBAN strutturalmente validi che superano l'algoritmo di controllo MOD 97 come specificato nello standard ISO 13616. Sebbene gli IBAN generati siano matematicamente validi, sono casuali e non collegati a conti bancari reali, rendendoli perfetti per test ma non per transazioni reali.
Lo strumento attualmente supporta i formati IBAN per Germania, Regno Unito, Francia, Spagna, Italia, Paesi Bassi, Svizzera, Austria, Belgio e Polonia. Questi coprono i formati IBAN più comunemente utilizzati in Europa.
No. Gli IBAN creati da questo generatore sono validi strutturalmente ma generati casualmente. Non sono collegati a conti bancari reali e dovrebbero essere utilizzati solo per scopi di test, educativi o dimostrativi.
Il validatore controlla diversi aspetti di un IBAN:
No. Sebbene gli IBAN siano spesso visualizzati con spazi per leggibilità (di solito in gruppi di quattro caratteri), gli spazi vengono ignorati durante la validazione. Il nostro strumento gestisce sia IBAN formattati che non formattati.
No. Questo strumento funziona interamente nel tuo browser. Nessun dato IBAN viene inviato a server, memorizzato o condiviso con terze parti. I tuoi dati rimangono privati e sicuri.
Attualmente, lo strumento convalida solo gli IBAN dei paesi supportati elencati nel menu a discesa. Se hai bisogno di validazione per paesi aggiuntivi, ti preghiamo di farcelo sapere tramite il modulo di feedback.
Un IBAN potrebbe fallire la validazione per diversi motivi:
Accogliamo con favore il feedback per migliorare lo strumento. Ti preghiamo di utilizzare il modulo di feedback accessibile tramite il link in fondo alla pagina per segnalare eventuali problemi o suggerire miglioramenti.
Per gli sviluppatori interessati a implementare la validazione e la generazione degli IBAN nelle proprie applicazioni, ecco esempi di codice in vari linguaggi di programmazione:
1function validateIban(iban) {
2 // Rimuovi spazi e converti in maiuscolo
3 const cleanedIban = iban.replace(/\s/g, '').toUpperCase();
4
5 // Controllo del formato di base
6 if (!/^[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}$/.test(cleanedIban)) {
7 return false;
8 }
9
10 // Riordina e converti lettere in numeri
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 // Calcola 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// Esempio di utilizzo
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 (cifre di controllo non valide)
321def validate_iban(iban):
2 # Rimuovi spazi e converti in maiuscolo
3 iban = iban.replace(' ', '').upper()
4
5 # Controllo del formato di base
6 if not (len(iban) > 4 and iban[:2].isalpha() and iban[2:4].isdigit()):
7 return False
8
9 # Sposta i primi 4 caratteri alla fine
10 rearranged = iban[4:] + iban[:4]
11
12 # Converti lettere in numeri (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 # Controlla se mod 97 è uguale a 1
21 return int(converted) % 97 == 1
22
23# Esempio di utilizzo
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 (cifre di controllo non valide)
271public class IbanValidator {
2 public static boolean validateIban(String iban) {
3 // Rimuovi spazi e converti in maiuscolo
4 String cleanedIban = iban.replaceAll("\\s", "").toUpperCase();
5
6 // Controllo del formato di base
7 if (!cleanedIban.matches("[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}")) {
8 return false;
9 }
10
11 // Sposta i primi 4 caratteri alla fine
12 String rearranged = cleanedIban.substring(4) + cleanedIban.substring(0, 4);
13
14 // Converti lettere in numeri
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 // Calcola 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 // Aggiungi altri paesi se necessario
7 };
8
9 if (!countryFormats[countryCode]) {
10 throw new Error(`Il codice paese ${countryCode} non è supportato`);
11 }
12
13 // Genera un BBAN casuale in base al formato del paese
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 // Genera caratteri numerici
24 for (let j = 0; j < count; j++) {
25 bban += Math.floor(Math.random() * 10);
26 }
27 } else if (type === 'a') {
28 // Genera caratteri alfabetici
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 // Genera caratteri alfanumerici
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 // Calcola le cifre di controllo
48 const checkDigits = calculateCheckDigits(countryCode, bban);
49
50 return countryCode + checkDigits + bban;
51}
52
53function calculateCheckDigits(countryCode, bban) {
54 // Crea un IBAN iniziale con '00' come cifre di controllo
55 const initialIban = countryCode + '00' + bban;
56
57 // Riordina e converti lettere in numeri
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 // Calcola 98 meno 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// Esempio di utilizzo
77console.log(generateIban('DE')); // Genera un IBAN tedesco valido
78console.log(generateIban('GB')); // Genera un IBAN del Regno Unito valido
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 # Aggiungi altri paesi se necessario
10 }
11
12 if country_code not in country_formats:
13 raise ValueError(f"Il codice paese {country_code} non è supportato")
14
15 # Genera un BBAN casuale in base al formato del paese
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': # Numerico
25 bban += ''.join(random.choices(string.digits, k=count))
26 elif type_char == 'a': # Alfabetico
27 bban += ''.join(random.choices(string.ascii_uppercase, k=count))
28 elif type_char == 'c': # Alfanumerico
29 bban += ''.join(random.choices(string.ascii_uppercase + string.digits, k=count))
30
31 i += 1 + len(str(count))
32
33 # Calcola le cifre di controllo
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 # Crea una stringa per il calcolo delle cifre di controllo
40 check_string = bban + country_code + '00'
41
42 # Converti lettere in numeri (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 # Calcola 98 meno mod 97
51 remainder = int(numeric) % 97
52 check_digits = str(98 - remainder).zfill(2)
53
54 return check_digits
55
56# Esempio di utilizzo
57print(generate_iban('DE')) # Genera un IBAN tedesco valido
58print(generate_iban('GB')) # Genera un IBAN del Regno Unito valido
59Lo strumento Generatore e Validatore IBAN fornisce una soluzione semplice ma potente per test e scopi educativi relativi agli identificatori bancari internazionali. Offrendo sia capacità di generazione che di validazione in un'interfaccia user-friendly, elimina la necessità di configurazioni complesse o integrazioni di terze parti.
Che tu stia sviluppando applicazioni finanziarie, testando sistemi di pagamento o apprendendo gli standard bancari internazionali, questo strumento offre un modo semplice per lavorare con gli IBAN. La convalida completa assicura che tutti gli IBAN generati siano strutturalmente solidi e conformi agli standard internazionali.
Prova a generare o convalidare un IBAN ora per sperimentare le capacità dello strumento in prima persona!
Scopri più strumenti che potrebbero essere utili per il tuo flusso di lavoro