Créez des IBAN aléatoires conformes au format ou validez ceux existants avec notre outil simple. Parfait pour tester des applications financières, des logiciels bancaires et à des fins éducatives.
L'outil de génération et de validation d'IBAN (Numéro de Compte Bancaire International) est un outil complet conçu pour des tests et des vérifications dans des applications financières, des logiciels bancaires et des contextes éducatifs. Cette application conviviale offre deux fonctionnalités essentielles : générer des IBAN aléatoires conformes au format et valider l'intégrité structurelle des IBAN saisies par l'utilisateur. Que vous soyez un développeur testant un logiciel financier, un spécialiste QA vérifiant des applications bancaires, ou un éducateur expliquant les normes bancaires internationales, cet outil fournit une solution simple sans nécessiter de configurations complexes ou d'intégrations tierces.
Les IBAN (Numéros de Compte Bancaire International) sont des identifiants de compte standardisés utilisés à l'international pour faciliter les transactions transfrontalières et réduire les erreurs dans les transferts d'argent internationaux. Chaque IBAN se compose d'un code pays, de chiffres de contrôle et d'un numéro de compte bancaire de base (BBAN) qui suit des formats spécifiques à chaque pays. Notre outil prend en charge plusieurs formats de pays et garantit que tous les IBAN générés passent l'algorithme de validation MOD 97 spécifié dans la norme ISO 13616.
Un IBAN se compose de jusqu'à 34 caractères alphanumériques, bien que la longueur exacte varie selon le pays. La structure standard comprend :
Par exemple, un IBAN allemand suit la structure DE2!n8!n10!n où :
DE est le code pays2!n représente deux chiffres de contrôle numériques8!n représente un code de banque à huit chiffres10!n représente un numéro de compte à dix chiffresDifférents pays ont différents formats de BBAN, ce qui entraîne des longueurs d'IBAN variables :
| Pays | Longueur | Structure | Exemple |
|---|---|---|---|
| Allemagne (DE) | 22 | DE2!n8!n10!n | DE89370400440532013000 |
| Royaume-Uni (GB) | 22 | GB2!n4!a6!n8!n | GB29NWBK60161331926819 |
| France (FR) | 27 | FR2!n5!n5!n11!c2!n | FR1420041010050500013M02606 |
| Espagne (ES) | 24 | ES2!n4!n4!n1!n1!n10!n | ES9121000418450200051332 |
| Italie (IT) | 27 | IT2!n1!a5!n5!n12!c | IT60X0542811101000000123456 |
Le processus de validation de l'IBAN utilise l'algorithme MOD 97 tel que spécifié dans la norme ISO 7064. Voici comment cela fonctionne :
Mathématiquement, cela est représenté comme suit :
Notre validateur implémente cet algorithme pour vérifier l'intégrité structurelle de tout IBAN saisi par les utilisateurs.
Le générateur d'IBAN crée des IBAN aléatoires mais valides à des fins de test. Les principales caractéristiques incluent :
Le générateur crée des IBAN en :
Le validateur d'IBAN vérifie l'intégrité structurelle des IBAN saisis par l'utilisateur. Les principales caractéristiques incluent :
Le validateur effectue plusieurs vérifications :
L'outil de génération et de validation d'IBAN sert plusieurs objectifs dans différents domaines :
Bien que notre outil de génération et de validation d'IBAN offre une expérience simplifiée pour les tests, il existe d'autres approches à considérer :
Notre outil comble le fossé entre ces alternatives en fournissant une interface simple et accessible pour la génération et la validation sans nécessiter d'intégration technique ou d'abonnements payants.
Un IBAN (Numéro de Compte Bancaire International) est un système de numérotation international standardisé développé pour identifier les comptes bancaires à travers les frontières nationales. Il a été établi par l'Organisation internationale de normalisation (ISO) pour faciliter les transactions internationales sans erreur.
Le générateur d'IBAN crée des IBAN structurellement valides qui passent l'algorithme de vérification MOD 97 tel que spécifié dans la norme ISO 13616. Bien que les IBAN générés soient mathématiquement valides, ils sont aléatoires et non liés à de véritables comptes bancaires, ce qui les rend parfaits pour les tests mais pas pour des transactions réelles.
L'outil prend actuellement en charge les formats d'IBAN pour l'Allemagne, le Royaume-Uni, la France, l'Espagne, l'Italie, les Pays-Bas, la Suisse, l'Autriche, la Belgique et la Pologne. Ceux-ci couvrent les formats d'IBAN les plus couramment utilisés en Europe.
Non. Les IBAN créés par ce générateur sont structurellement valides mais générés aléatoirement. Ils ne sont pas connectés à de vrais comptes bancaires et doivent uniquement être utilisés à des fins de test, éducatives ou de démonstration.
Le validateur vérifie plusieurs aspects d'un IBAN :
Non. Bien que les IBAN soient souvent affichés avec des espaces pour la lisibilité (généralement en groupes de quatre caractères), les espaces sont ignorés lors de la validation. Notre outil gère à la fois les IBAN formatés et non formatés.
Non. Cet outil fonctionne entièrement dans votre navigateur. Aucune donnée d'IBAN n'est envoyée à un serveur, stockée ou partagée avec des tiers. Vos données restent privées et sécurisées.
Actuellement, l'outil ne valide que les IBAN des pays pris en charge figurant dans la liste déroulante. Si vous avez besoin de validation pour des pays supplémentaires, veuillez nous le faire savoir via le formulaire de retour.
Un IBAN pourrait échouer à la validation pour plusieurs raisons :
Nous accueillons les retours pour améliorer l'outil. Veuillez utiliser le formulaire de retour accessible via le lien en bas de la page pour signaler tout problème ou suggérer des améliorations.
Pour les développeurs intéressés par l'implémentation de la validation et de la génération d'IBAN dans leurs propres applications, voici des exemples de code dans divers langages de programmation :
1function validateIban(iban) {
2 // Supprimer les espaces et convertir en majuscules
3 const cleanedIban = iban.replace(/\s/g, '').toUpperCase();
4
5 // Vérification de format de base
6 if (!/^[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}$/.test(cleanedIban)) {
7 return false;
8 }
9
10 // Réarranger et convertir les lettres en chiffres
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 // Calculer le 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// Exemple d'utilisation
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 (chiffres de contrôle invalides)
321def validate_iban(iban):
2 # Supprimer les espaces et convertir en majuscules
3 iban = iban.replace(' ', '').upper()
4
5 # Vérification de format de base
6 if not (len(iban) > 4 and iban[:2].isalpha() and iban[2:4].isdigit()):
7 return False
8
9 # Déplacer les 4 premiers caractères à la fin
10 rearranged = iban[4:] + iban[:4]
11
12 # Convertir les lettres en chiffres (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 # Vérifier si le mod 97 est égal à 1
21 return int(converted) % 97 == 1
22
23# Exemple d'utilisation
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 (chiffres de contrôle invalides)
271public class IbanValidator {
2 public static boolean validateIban(String iban) {
3 // Supprimer les espaces et convertir en majuscules
4 String cleanedIban = iban.replaceAll("\\s", "").toUpperCase();
5
6 // Vérification de format de base
7 if (!cleanedIban.matches("[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}")) {
8 return false;
9 }
10
11 // Déplacer les 4 premiers caractères à la fin
12 String rearranged = cleanedIban.substring(4) + cleanedIban.substring(0, 4);
13
14 // Convertir les lettres en chiffres
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 // Calculer le 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 // Ajouter d'autres pays si nécessaire
7 };
8
9 if (!countryFormats[countryCode]) {
10 throw new Error(`Le code pays ${countryCode} n'est pas pris en charge`);
11 }
12
13 // Générer un BBAN aléatoire basé sur le format du pays
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 // Générer des caractères numériques
24 for (let j = 0; j < count; j++) {
25 bban += Math.floor(Math.random() * 10);
26 }
27 } else if (type === 'a') {
28 // Générer des caractères alphabétiques
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 // Générer des caractères alphanumériques
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 // Calculer les chiffres de contrôle
48 const checkDigits = calculateCheckDigits(countryCode, bban);
49
50 return countryCode + checkDigits + bban;
51}
52
53function calculateCheckDigits(countryCode, bban) {
54 // Créer un IBAN initial avec '00' comme chiffres de contrôle
55 const initialIban = countryCode + '00' + bban;
56
57 // Réarranger et convertir les lettres en chiffres
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 // Calculer 98 moins 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// Exemple d'utilisation
77console.log(generateIban('DE')); // Génère un IBAN allemand valide
78console.log(generateIban('GB')); // Génère un IBAN britannique valide
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 # Ajouter d'autres pays si nécessaire
10 }
11
12 if country_code not in country_formats:
13 raise ValueError(f"Le code pays {country_code} n'est pas pris en charge")
14
15 # Générer un BBAN aléatoire basé sur le format du pays
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érique
25 bban += ''.join(random.choices(string.digits, k=count))
26 elif type_char == 'a': # Alphabétique
27 bban += ''.join(random.choices(string.ascii_uppercase, k=count))
28 elif type_char == 'c': # Alphanumérique
29 bban += ''.join(random.choices(string.ascii_uppercase + string.digits, k=count))
30
31 i += 1 + len(str(count))
32
33 # Calculer les chiffres de contrôle
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 # Créer une chaîne pour le calcul des chiffres de contrôle
40 check_string = bban + country_code + '00'
41
42 # Convertir les lettres en chiffres (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 # Calculer 98 moins mod 97
51 remainder = int(numeric) % 97
52 check_digits = str(98 - remainder).zfill(2)
53
54 return check_digits
55
56# Exemple d'utilisation
57print(generate_iban('DE')) # Génère un IBAN allemand valide
58print(generate_iban('GB')) # Génère un IBAN britannique valide
59L'outil de génération et de validation d'IBAN fournit une solution simple mais puissante pour les tests et les objectifs éducatifs liés aux identifiants bancaires internationaux. En offrant à la fois des capacités de génération et de validation dans une interface conviviale, il élimine le besoin de configurations complexes ou d'intégrations tierces.
Que vous développiez des applications financières, testiez des systèmes de paiement ou appreniez les normes bancaires internationales, cet outil offre un moyen simple de travailler avec des IBAN. La validation complète garantit que tous les IBAN générés sont structurellement sains et conformes aux normes internationales.
Essayez de générer ou de valider un IBAN maintenant pour découvrir les capacités de l'outil par vous-même !
Découvrez plus d'outils qui pourraient être utiles pour votre flux de travail