Crea IBAN aleatorios que cumplen con el formato o valida los existentes con nuestra herramienta sencilla. Perfecto para probar aplicaciones financieras, software bancario y fines educativos.
El Generador y Validador de Número de Cuenta Bancaria Internacional (IBAN) es una herramienta integral diseñada para pruebas y verificación en aplicaciones financieras, software bancario y contextos educativos. Esta aplicación fácil de usar ofrece dos funciones esenciales: generar IBAN aleatorios que cumplen con el formato y validar la integridad estructural de los IBAN ingresados por el usuario. Ya sea que seas un desarrollador probando software financiero, un especialista en control de calidad verificando aplicaciones bancarias o un educador explicando estándares bancarios internacionales, esta herramienta proporciona una solución sencilla sin requerir configuraciones complejas o integraciones de terceros.
Los IBAN (Números de Cuenta Bancaria Internacional) son identificadores de cuentas estandarizados utilizados internacionalmente para facilitar transacciones transfronterizas y reducir errores en transferencias de dinero internacionales. Cada IBAN consiste en un código de país, dígitos de verificación y un número de cuenta bancaria básico (BBAN) que sigue formatos específicos de cada país. Nuestra herramienta admite múltiples formatos de países y asegura que todos los IBAN generados pasen el algoritmo de validación MOD 97 especificado en la norma ISO 13616.
Un IBAN consta de hasta 34 caracteres alfanuméricos, aunque la longitud exacta varía según el país. La estructura estándar incluye:
Por ejemplo, un IBAN alemán sigue la estructura DE2!n8!n10!n donde:
DE es el código de país2!n representa dos dígitos numéricos de verificación8!n representa un código bancario de ocho dígitos10!n representa un número de cuenta de diez dígitosDiferentes países tienen diferentes formatos de BBAN, resultando en longitudes variables de IBAN:
| País | Longitud | Estructura | Ejemplo |
|---|---|---|---|
| Alemania (DE) | 22 | DE2!n8!n10!n | DE89370400440532013000 |
| Reino Unido (GB) | 22 | GB2!n4!a6!n8!n | GB29NWBK60161331926819 |
| Francia (FR) | 27 | FR2!n5!n5!n11!c2!n | FR1420041010050500013M02606 |
| España (ES) | 24 | ES2!n4!n4!n1!n1!n10!n | ES9121000418450200051332 |
| Italia (IT) | 27 | IT2!n1!a5!n5!n12!c | IT60X0542811101000000123456 |
El proceso de validación del IBAN utiliza el algoritmo MOD 97 según lo especificado en la norma ISO 7064. Así es como funciona:
Matemáticamente, esto se representa como:
Nuestro validador implementa este algoritmo para verificar la integridad estructural de cualquier IBAN ingresado por los usuarios.
El generador de IBAN crea IBAN aleatorios pero válidos para fines de prueba. Las características clave incluyen:
El generador crea IBAN al:
El validador de IBAN verifica la integridad estructural de los IBAN ingresados por el usuario. Las características clave incluyen:
El validador realiza múltiples comprobaciones:
La herramienta Generador y Validador de IBAN sirve múltiples propósitos en diferentes dominios:
Si bien nuestra herramienta Generador y Validador de IBAN ofrece una experiencia simplificada para fines de prueba, hay enfoques alternativos a considerar:
Nuestra herramienta cierra la brecha entre estas alternativas al proporcionar una interfaz simple y accesible tanto para la generación como para la validación sin requerir integración técnica o suscripciones pagadas.
Un IBAN (Número de Cuenta Bancaria Internacional) es un sistema de numeración internacional estandarizado desarrollado para identificar cuentas bancarias a través de fronteras nacionales. Fue establecido por la Organización Internacional de Normalización (ISO) para facilitar transacciones internacionales sin errores.
El generador de IBAN crea IBAN estructuralmente válidos que pasan el algoritmo de verificación MOD 97 según lo especificado en la norma ISO 13616. Si bien los IBAN generados son válidos matemáticamente, son aleatorios y no están vinculados a cuentas bancarias reales, lo que los hace perfectos para pruebas pero no para transacciones reales.
La herramienta actualmente admite formatos de IBAN para Alemania, Reino Unido, Francia, España, Italia, Países Bajos, Suiza, Austria, Bélgica y Polonia. Estos cubren los formatos de IBAN más comúnmente utilizados en Europa.
No. Los IBAN creados por este generador son válidos estructuralmente pero generados aleatoriamente. No están conectados a cuentas bancarias reales y deben usarse solo para pruebas, educación o fines de demostración.
El validador comprueba varios aspectos de un IBAN:
No. Si bien los IBAN a menudo se muestran con espacios para mejorar la legibilidad (generalmente en grupos de cuatro caracteres), los espacios se ignoran durante la validación. Nuestra herramienta maneja tanto IBAN formateados como no formateados.
No. Esta herramienta opera completamente en tu navegador. No se envían datos de IBAN a ningún servidor, no se almacenan ni se comparten con terceros. Tus datos permanecen privados y seguros.
Actualmente, la herramienta solo valida IBAN de los países admitidos que se enumeran en el menú desplegable. Si necesitas validación para países adicionales, háznoslo saber a través del formulario de comentarios.
Un IBAN puede fallar en la validación por varias razones:
Agradecemos los comentarios para mejorar la herramienta. Por favor, utiliza el formulario de comentarios accesible a través del enlace en la parte inferior de la página para informar cualquier problema o sugerir mejoras.
Para los desarrolladores interesados en implementar la validación y generación de IBAN en sus propias aplicaciones, aquí hay ejemplos de código en varios lenguajes de programación:
1function validateIban(iban) {
2 // Eliminar espacios y convertir a mayúsculas
3 const cleanedIban = iban.replace(/\s/g, '').toUpperCase();
4
5 // Comprobar formato básico
6 if (!/^[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}$/.test(cleanedIban)) {
7 return false;
8 }
9
10 // Reorganizar y convertir letras a números
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 // Calcular 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// Ejemplo de uso
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 (dígitos de verificación inválidos)
321def validate_iban(iban):
2 # Eliminar espacios y convertir a mayúsculas
3 iban = iban.replace(' ', '').upper()
4
5 # Comprobación de formato básico
6 if not (len(iban) > 4 and iban[:2].isalpha() and iban[2:4].isdigit()):
7 return False
8
9 # Mover los primeros 4 caracteres al final
10 rearranged = iban[4:] + iban[:4]
11
12 # Convertir letras a números (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 # Comprobar si mod 97 es igual a 1
21 return int(converted) % 97 == 1
22
23# Ejemplo de uso
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 (dígitos de verificación inválidos)
271public class IbanValidator {
2 public static boolean validateIban(String iban) {
3 // Eliminar espacios y convertir a mayúsculas
4 String cleanedIban = iban.replaceAll("\\s", "").toUpperCase();
5
6 // Comprobación de formato básico
7 if (!cleanedIban.matches("[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}")) {
8 return false;
9 }
10
11 // Mover los primeros 4 caracteres al final
12 String rearranged = cleanedIban.substring(4) + cleanedIban.substring(0, 4);
13
14 // Convertir letras a números
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 // Calcular 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 // Agregar más países según sea necesario
7 };
8
9 if (!countryFormats[countryCode]) {
10 throw new Error(`El código de país ${countryCode} no es compatible`);
11 }
12
13 // Generar BBAN aleatorio basado en el formato del país
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 // Generar caracteres numéricos
24 for (let j = 0; j < count; j++) {
25 bban += Math.floor(Math.random() * 10);
26 }
27 } else if (type === 'a') {
28 // Generar caracteres alfabéticos
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 // Generar caracteres alfanuméricos
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 // Calcular dígitos de verificación
48 const checkDigits = calculateCheckDigits(countryCode, bban);
49
50 return countryCode + checkDigits + bban;
51}
52
53function calculateCheckDigits(countryCode, bban) {
54 // Crear IBAN inicial con '00' como dígitos de verificación
55 const initialIban = countryCode + '00' + bban;
56
57 // Reorganizar y convertir letras a números
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 // Calcular 98 menos 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// Ejemplo de uso
77console.log(generateIban('DE')); // Genera un IBAN alemán válido
78console.log(generateIban('GB')); // Genera un IBAN del Reino Unido válido
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 # Agregar más países según sea necesario
10 }
11
12 if country_code not in country_formats:
13 raise ValueError(f"El código de país {country_code} no es compatible")
14
15 # Generar BBAN aleatorio basado en el formato del país
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': # Numérico
25 bban += ''.join(random.choices(string.digits, k=count))
26 elif type_char == 'a': # Alfabético
27 bban += ''.join(random.choices(string.ascii_uppercase, k=count))
28 elif type_char == 'c': # Alfanumérico
29 bban += ''.join(random.choices(string.ascii_uppercase + string.digits, k=count))
30
31 i += 1 + len(str(count))
32
33 # Calcular dígitos de verificación
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 # Crear cadena para el cálculo de dígitos de verificación
40 check_string = bban + country_code + '00'
41
42 # Convertir letras a números (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 # Calcular 98 menos mod 97
51 remainder = int(numeric) % 97
52 check_digits = str(98 - remainder).zfill(2)
53
54 return check_digits
55
56# Ejemplo de uso
57print(generate_iban('DE')) # Genera un IBAN alemán válido
58print(generate_iban('GB')) # Genera un IBAN del Reino Unido válido
59La herramienta Generador y Validador de IBAN proporciona una solución simple pero poderosa para pruebas y propósitos educativos relacionados con identificadores bancarios internacionales. Al ofrecer capacidades tanto de generación como de validación en una interfaz fácil de usar, elimina la necesidad de configuraciones complejas o integraciones de terceros.
Ya sea que estés desarrollando aplicaciones financieras, probando sistemas de pago o aprendiendo sobre estándares bancarios internacionales, esta herramienta ofrece una forma sencilla de trabajar con IBAN. La validación integral asegura que todos los IBAN generados sean estructuralmente sólidos y cumplan con los estándares internacionales.
¡Prueba generar o validar un IBAN ahora para experimentar las capacidades de la herramienta de primera mano!
Descubre más herramientas que podrían ser útiles para tu flujo de trabajo