Basic Bank Account Number

Un article de Wikipédia, l'encyclopédie libre.
(Redirigé depuis Relevé d'identité bancaire)
Aller à : navigation, rechercher
Page d'aide sur l'homonymie Pour les articles homonymes, voir RIB.

Le BBAN est une subdivision locale de l'IBAN délivré par la banque et que l'on remet à un débiteur ou un créancier dans le but d'opérer des virements bancaires ou des prélèvements bancaires à partir d'un compte courant. On trouve souvent un RIB à la fin des carnets de chèques ou en tête du relevé de compte.

On utilise parfois, en France, les appellations :

  • RIB pour relevé d’identité bancaire en France,
  • RICE pour relevé d’identité Caisse d’épargne
  • RIP, à l'usage désuet, et qui mentionnait les références d'un compte courant postal ouvert auprès des services financiers de La Poste ; les RIB sont désormais l'usage à La Banque postale.

Composition[modifier | modifier le code]

Composition du BBAN
3 à 12 positions 8 à 20 positions
IID BAN


  • IID : identification de l’établissement financier
  • BAN : numéro de compte bancaire

Il n'a pas plus de 30 positions. Chaque pays a la responsabilité de définir le format de son BBAN.

Exemples[modifier | modifier le code]

  • France et Monaco (23 caractères) Format : BBBBBGGGGGCCCCCCCCCCCKK
B = code banque (5 chiffres), G = code guichet (5 chiffres), C = numéro de compte (11 chiffres et/ou lettres), K = clé RIB (2 chiffres entre 01 et 97)
  • Belgique (12 chiffres) Format : BBBCCCCCCCKK
KK = BBBCCCCCCC modulo 97
  • Allemagne (18 chiffres) Format BBBBBBBBCCCCCCCCCC
B = code banque (8 chiffres), C = numéro de compte (10 chiffres. Si moins, compléter à gauche avec des 0)
Nota: le numéro de compte allemand (C) contient une clé de contrôle, mais sa position et son calcul diffèrent d'une banque à l'autre. Il existe plus de 100 méthodes différentes de calcul de la clé en Allemagne (source : http://de.wikipedia.org/wiki/Kontonummer)

Clef RIB[modifier | modifier le code]

Article détaillé : Clé RIB.

Clé = 97 − ([concaténation de banque,guichet,compte] * 100 modulo 97). Cette clé est proche de celle du numéro de Sécurité sociale français, à la différence qu'il n'est pas centuplé. Si le compte comporte des lettres (banques françaises Banque postale et Crédit lyonnais), remplacer la lettre par son index de 1 à 9 dans l'alphabet (A = 1, \ldots, I = 9, J = 1, etc.) en laissant un saut entre R et S.

Le chéquier[modifier | modifier le code]

Le relevé d'identité bancaire, sur le carnet de chèque, est composé de :

  • l'International Banking Account Number (IBAN), numéro de compte à la norme internationale ISO n° 13616
  • le Bank Identification Code (BIC), identifiant de l'établissement financier (la banque) à la norme internationale ISO n° 9362
  • le nom et l'adresse du titulaire du compte, en date d'établissement du carnet de chèque (les chèques restant valides après déménagement)
  • le nom de l'établissement financier (la banque) et du guichet de domiciliation (l'agence bancaire)

Vérification du RIB[modifier | modifier le code]

Algorithme[modifier | modifier le code]

La validité d'un RIB se calcule grâce à la clé de celui-ci.

La première étape consiste à remplacer les lettres présentes par des chiffres pour faciliter le calcul.

Tableau de transformation des caractères
Caractère Chiffre représentant
0 0
1, A, J 1
2, B, K, S 2
3, C, L, T 3
4, D, M, U 4
5, E, N, V 5
6, F, O, W 6
7, G, P, X 7
8, H, Q, Y 8
9, I, R, Z 9

Pour faire la transformation, il suffit de se placer en base 36 (base 10 + 26 lettres) et d'appliquer le calcul suivant sur chaque caractère (transformé en nombre currentCharValue) puis de remplacer le sélectionné par le nombre donné :


\text{currentCharValue} + 2^{\frac{\text{currentCharValue}-10}9}\pmod{10}


L'étape suivante (facultative) consiste à décomposer le code et multiplier chaque partie par une constante et en faire la somme. Enfin, le code est correct si le nombre obtenu (soit par simple concaténation de nos différentes parties, soit par décomposition) est congru à 0 modulo 97.


\text{bankCode} * 89 + \text{counter} * 15 + \text{account} * 3 + \text{key} \equiv 0 \pmod{97}

Algorithme de vérification en C#[modifier | modifier le code]

La fonction check_rib retourne vrai ou faux en fonction de la validité des informations.

 private static Regex regex_rib;
 
        /// <summary>
        /// Vérifie la validité d'un RIB
        /// </summary>
        /// <param name="rib">Le RIB à vérifier</param>
        /// <returns>true si le RIB est valide, false sinon</returns>
        public static bool IsValidRib(string rib)
        {
            // Suppression des espaces et tirets
            string tmp = rib.Replace(" ", "").Replace("-", "");
 
            // Vérification du format BBBBBGGGGGCCCCCCCCCCCKK
            // B : banque
            // G : guichet
            // C : numéro de compte
            // K : clé RIB
            if (regex_rib == null)
            {
                regex_rib = new Regex(@"(?<B>\d{5})(?<G>\d{5})(?<C>\w{11})(?<K>\d{2})", RegexOptions.Compiled);
            }
            Match m = regex_rib.Match(tmp);
            if (!m.Success)
                return false;
 
            // Extraction des composants
            string b_s = m.Groups["B"].Value;
            string g_s = m.Groups["G"].Value;
            string c_s = m.Groups["C"].Value;
            string k_s = m.Groups["K"].Value;
 
            // Remplacement des lettres par des chiffres dans le numéro de compte
            StringBuilder sb = new StringBuilder();
            foreach (char ch in c_s.ToUpper())
            {
                if (char.IsDigit(ch))
                    sb.Append(ch);
                else
                    sb.Append(RibLetterToDigit(ch));
            }
            c_s = sb.ToString();
 
            // Séparation du numéro de compte pour tenir sur 32bits
            string d_s = c_s.Substring(0, 6);
            c_s = c_s.Substring(6, 5);
 
            // Calcul de la clé RIB
            // Algo ici : http://fr.wikipedia.org/wiki/Clé_RIB#Algorithme_de_calcul_qui_fonctionne_avec_des_entiers_32_bits
 
            int b = int.Parse(b_s);
            int g = int.Parse(g_s);
            int d = int.Parse(d_s);
            int c = int.Parse(c_s);
            int k = int.Parse(k_s);
 
            int calculatedKey = 97 - ((89 * b + 15 * g + 76 * d + 3 * c) % 97);
 
            return (k == calculatedKey);
        }
 
        /// <summary>
        /// Convertit une lettre d'un RIB en un chiffre selon la table suivante :
        /// 1 2 3 4 5 6 7 8 9
        /// A B C D E F G H I
        /// J K L M N O P Q R
        /// _ S T U V W X Y Z
        /// </summary>
        /// <param name="c">La lettre à convertir</param>
        /// <returns>Le chiffre de remplacement</returns>
        public static char RibLetterToDigit(char letter)
        {
            if (letter >= 'A' && letter <= 'I')
            {
                return (char)(letter - 'A' + '1');
            }
            else if (letter >= 'J' && letter <= 'R')
            {
                return (char)(letter - 'J' + '1');
            }
            else if (letter >= 'S' && letter <= 'Z')
            {
                return (char)(letter - 'S' + '2');
            }
            else
                throw new ArgumentOutOfRangeException("Le caractère à convertir doit être une lettre majuscule dans la plage A-Z");
        }

Algorithme de clé RIB | developpez.com

Algorithme de vérification en PHP[modifier | modifier le code]

La fonction check_rib retourne vrai ou faux en fonction de la validité des informations.

function check_rib($cbanque, $cguichet, $nocompte, $clerib) {
	$tabcompte = "";
	$len = strlen($nocompte);
	if ($len != 11) {
		return false;
	}
	for ($i = 0; $i < $len; $i++) {
		$car = substr($nocompte, $i, 1);
		if (!is_numeric($car)) {
			$c = ord($car) - (ord('A') - 1);
			$b = (($c + pow ( 2, ($c - 10) / 9 )) % 10) + (($c > 18 && $c < 25) ? 1 : 0);
			$tabcompte .= $b;
		}
		else {
			$tabcompte .= $car;
		}
	}
	$int = $cbanque . $cguichet . $tabcompte . $clerib;
	return (strlen($int) >= 21 && bcmod($int, 97) == 0);
}

Algorithme de vérification en Java[modifier | modifier le code]

import java.math.BigDecimal;
 
public class Validation{
    public boolean checkRib(String rib) {
        StringBuilder extendedRib = new StringBuilder(rib.length());
        for (char currentChar : rib.toCharArray()) {
            //Works on base 36
            int currentCharValue = Character.digit(currentChar, Character.MAX_RADIX);
            //Convert character to simple digit
            extendedRib.append(currentCharValue<10?currentCharValue:(currentCharValue + (int) StrictMath.pow(2,(currentCharValue-10)/9))%10);
        }
 
        return new BigDecimal(extendedRib.toString()).remainder(new BigDecimal(97)).intValue() == 0;
    }
}

Algorithme de vérification en Ruby[modifier | modifier le code]

Avec :

  • rib : le RIB complet sans espace à passer à la méthode.
  def rib?(rib)
    bank, office, account, key = rib.match(/^(\d{5})(\d{5})([[:alnum:]]{11})(\d{2})$/).captures
    account                    = account.each_char.inject('') do |sum, char|
      char = char.to_i 36
      sum  += ((char + 2 ** ((char - 10)/9)).to_i % 10).to_s
    end
    result                     = bank + office + account + key
    result.size >= 21 && result.to_i % 97 == 0
  rescue
    # Le RIB n’est pas valide
    false
  end

Algorithme de vérification en Perl[modifier | modifier le code]

Avec :

  • $cbanque : code de la banque
  • $cguichet : code du guichet
  • $nocompte : numéro de compte
  • $clerib : clé rib
    use Math::BigInt;
    my %letter_substitution = ("A" => 1, "B" => 2, "C" => 3, "D" => 4, "E" => 5, "F" => 6, "G" => 7, "H" => 8, "I" => 9,
                               "J" => 1, "K" => 2, "L" => 3, "M" => 4, "N" => 5, "O" => 6, "P" => 7, "Q" => 8, "R" => 9,
                                         "S" => 2, "T" => 3, "U" => 4, "V" => 5, "W" => 6, "X" => 7, "Y" => 8, "Z" => 9); 
    my $tabcompte = ""; 
    my $len = length($nocompte);
    return 0 if ($len != 11);
    for (my $i = 0; $i < $len; $i++) {
        my $car = substr($nocompte, $i, 1); 
        if ($car !~ m/^\d$/) {
            my $b = $letter_substitution{uc($car)};
            my $c = ( $b + 2**(($b - 10)/9) ) % 10; 
            $tabcompte .= $c; 
        } else {
            $tabcompte .= $car;
        }   
    }   
    my $int = "$cbanque$cguichet$tabcompte$clerib";
    return (length($int) >= 21 && Math::BigInt->new($int)->bmod(97) == 0) ? 1 : 0;

Requête de vérification du dossier RIB par calcul de la clé RIB[modifier | modifier le code]

renseigner les codes Banque et Guichet ainsi que le numéro de compte à l'exécution de la requête SQL.

  SELECT Saisie.*
         ,97-MOD(Banque*89+Guichet*15+Compte*3,97) CleRIB
  FROM (SELECT substr(lpad(&Banque,5,'0'),1,5) Banque
              ,substr(lpad(&Guichet,5,'0'),1,5) Guichet
              ,translate(UPPER(substr(lpad('&Compte',11,'0'),1,11))
                       ,'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
                       , 12345678912345678923456789
               ) Compte
        FROM dual
       ) Saisie;

Algorithme de vérification en Python[modifier | modifier le code]

def check_bic(bic):
    replacement_table = {
            'AJaj': '1',
            'BKSbks': '2',
            'CLTclt': '3',
            'DMUdmu': '4',
            'ENVenv': '5',
            'FOWfow': '6',
            'GPXgpx': '7',
            'HQYhqy': '8',
            'IRZirz': '9',
            }
    if len(bic) != 23:
        return False
    for i in range(len(bic)):
        char = bic[i]
        for pattern in replacement_table.keys():
            if char in pattern:
                bic = bic.replace(char, replacement_table[pattern])
    bankcode = int(bic[:5])
    counter = int(bic[5:10])
    account = int(bic[10:21])
    key = int(bic[21:])
    return (bankcode*89 + counter*15 + account*3 + key) % 97 == 0

Algorithme de vérification en VBA ou VBE[modifier | modifier le code]

Conversion du RIB en IBAN[modifier | modifier le code]

Algorithme[modifier | modifier le code]

  1. Créer un IBAN temporaire, composé du code du pays : FR pour la France, suivi de " 00 " et du " code RIB "
  2. Déplacer les 4 premiers caractères de l’IBAN vers la droite du numéro.
  3. Convertir les lettres en chiffres, selon le principe "A" vaut "10" ... "Z" vaut "35".
  4. Calculer le modulo 97 et retrancher le reste de 98. Si le résultat comporte un seul chiffre, insérer un zéro devant.

Insérer le résultat ainsi obtenu à la position 3 de l’IBAN temporaire créé dans l’étape 1.

Algorithme de conversion du RIB en IBAN en C#[modifier | modifier le code]

 public static String GetIban(String codebanque, String codeGuichet, String numerocompte, String cle)
       {
           String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
           String tmp = codebanque + codeGuichet + numerocompte + cle + "FR00";
           tmp = tmp.ToUpper();
           foreach (char c in tmp.ToCharArray())
           {
               if (char.IsLetter(c))
               {
                   tmp = tmp.Replace(c.ToString(), (alphabet.IndexOf(c) + 10).ToString());
               }
           }
           var moduloRemainder = BigInteger.Parse(tmp) % 97;
           String ibanKey = (98 - moduloRemainder).ToString();
           if (ibanKey.Length == 1)
           {
               ibanKey = "0" + ibanKey;
           }
           return "FR" + ibanKey + codebanque + codeGuichet + numerocompte + cle;
       }

Algorithme de conversion du RIB en IBAN en Java[modifier | modifier le code]

public static String getIBAN(String codebanque, String codeGuichet, String numerocompte, String cle) {
 
    String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    String tmp = codebanque + codeGuichet + numerocompte + cle + "FR00";
    tmp = tmp.toUpperCase();
 
    for (char c : tmp.toCharArray()) {
        if (Character.isLetter(c)) {
            tmp  = tmp .replaceAll(String.valueOf(c), String.valueOf(alphabet.indexOf(c) + 10));
        }
    }
    String ibanKey =
            String.valueOf(new BigDecimal(98).subtract(new BigDecimal(tmp).remainder((new BigDecimal(97)))));
    if (ibanKey.length() == 1) {
        ibanKey = "0" + ibanKey;
    }
    return "FR" + ibanKey + codebanque + codeGuichet + numerocompte + cle;
}

Algorithme de conversion du RIB en IBAN en PHP[modifier | modifier le code]

function Rib2Iban($codebanque,$codeguichet,$numerocompte,$cle){
	$charConversion = array("A" => "10","B" => "11","C" => "12","D" => "13","E" => "14","F" => "15","G" => "16","H" => "17",
	"I" => "18","J" => "19","K" => "20","L" => "21","M" => "22","N" => "23","O" => "24","P" => "25","Q" => "26",
	"R" => "27","S" => "28","T" => "29","U" => "30","V" => "31","W" => "32","X" => "33","Y" => "34","Z" => "35");
 
	$tmpiban = strtr(strtoupper($codebanque.$codeguichet.$numerocompte.$cle)."FR00",$charConversion);
 
	// Soustraction du modulo 97 de l'IBAN temporaire à 98
	$cleiban = strval(98 - intval(bcmod($tmpiban,"97")));
 
	if (strlen($cleiban) == 1)
		$cleiban = "0".$cleiban;
 
	return "FR".$cleiban.$codebanque.$codeguichet.$numerocompte.$cle;
}

Algorithme de conversion du RIB en IBAN en Ruby[modifier | modifier le code]

Avec :

  • rib : le RIB complet sans espace à passer à la méthode.
  def rib_to_iban(rib)
    tmp_iban = "#{rib}FR00".each_char.map { |char| char.to_i(36).to_s }.join.to_i
    key = 98 - (tmp_iban % 97)
    "FR%.2d%s" % [key, rib]
  end

Algorithme de conversion du RIB en IBAN en Python[modifier | modifier le code]

Avec :

  • rib : le RIB complet sans espace à passer à la méthode.
def rib_to_iban(rib):
    tmp_iban = int("".join([str(int(c,36)) for c in rib+"FR00"]))
    key = 98 - (tmp_iban % 97)
    return "FR%.2d%s" % (key, rib)

Algorithme de conversion du RIB en IBAN en Oracle[modifier | modifier le code]

FUNCTION SO_F_RIB_IBAN(pi_va_rib IN VARCHAR2) RETURN VARCHAR2
IS
  l_i_loop INTEGER;
  l_va_return VARCHAR2(40);
  l_n_clee INTEGER;
BEGIN
  l_va_return := UPPER(pi_va_rib) || 'FR00';
 
  -- Transformation de A-Z en 10-35
  FOR l_i_loop IN 0 .. 25 LOOP
    l_va_return := REPLACE(l_va_return, CHR(65+l_i_loop), (10+l_i_loop));		
  END LOOP;
 
  -- Soustraction du modulo 97 de l'IBAN temporaire à 98
  l_n_clee := (98 - MOD(l_va_return,97));
 
  -- Retourne l'iban
  RETURN 'FR' || TRIM(TO_CHAR(l_n_clee, '00')) || UPPER(pi_va_rib);		
END SO_F_RIB_IBAN;

Articles connexes[modifier | modifier le code]

Références[modifier | modifier le code]