Validation Technique des Numéros SIREN et SIRET

Ce guide technique détaille les méthodes de validation des numéros SIREN et SIRET français. Vous apprendrez comment fonctionne l'algorithme de Luhn utilisé pour générer et vérifier les clés de contrôle, ainsi que les particularités de chaque type d'identifiant.

Pourquoi valider le format ?

La validation du format permet de détecter rapidement les erreurs de saisie avant d'interroger les bases de données officielles. Un numéro mal formaté ou avec une clé de contrôle incorrecte ne peut pas correspondre à une entreprise réelle. Cette première vérification évite des recherches inutiles et permet d'identifier immédiatement les numéros erronés.

Types d'erreurs détectables :
  • Nombre incorrect de chiffres
  • Caractères non numériques
  • Inversion de deux chiffres adjacents
  • Modification d'un seul chiffre
  • Clé de contrôle incorrecte

Structure du SIREN

Le numéro SIREN est composé de 9 chiffres, dont les 8 premiers sont attribués séquentiellement et le 9ème est une clé de contrôle :

Position 123456789
Rôle Numéro séquentiel Clé
Exemple 443061841

Algorithme de Luhn pour le SIREN

L'algorithme de Luhn (ou "modulo 10") est appliqué comme suit pour le SIREN :

  1. Numérotez les positions de 1 à 9 de gauche à droite
  2. Pour les positions paires (2, 4, 6, 8), multipliez le chiffre par 2
  3. Si le résultat est supérieur à 9, soustrayez 9 (équivalent à additionner les deux chiffres)
  4. Additionnez tous les résultats (positions impaires non modifiées + positions paires après opération)
  5. Le total doit être divisible par 10 pour un SIREN valide
Exemple de validation - SIREN 732 829 320 :
Position123456789
Chiffre732829320
×2 si pair76216218340
Si >9, -9762729340

Somme : 7 + 6 + 2 + 7 + 2 + 9 + 3 + 4 + 0 = 40

40 ÷ 10 = 4 (reste 0) → SIREN VALIDE ✓

Structure du SIRET

Le numéro SIRET est composé de 14 chiffres : le SIREN (9 chiffres) + le NIC (5 chiffres). La validation utilise également l'algorithme de Luhn, mais appliqué à l'ensemble des 14 chiffres.

Composant SIREN NIC
Positions 1 à 9 10 à 14
Exemple 732 829 320 00074

Algorithme de Luhn pour le SIRET

Pour le SIRET, l'algorithme de Luhn est appliqué avec une particularité : les positions impaires (1, 3, 5, 7, 9, 11, 13) sont multipliées par 2, contrairement au SIREN où ce sont les positions paires.

Exception importante : La Poste
Les établissements de La Poste (SIREN commençant par 356000000) ne suivent pas l'algorithme de Luhn standard en raison du très grand nombre d'établissements. Ces SIRET utilisent des règles de validation spécifiques.

Calculer la clé de contrôle

Pour calculer la clé de contrôle d'un SIREN incomplet (8 premiers chiffres connus), suivez cette méthode :

  1. Appliquez l'algorithme de Luhn aux 8 premiers chiffres
  2. Calculez la somme partielle (sans la 9ème position)
  3. La clé = (10 - (somme modulo 10)) modulo 10
Exemple - Calculer la clé pour 73282932X :
Position123456789
Chiffre73282932?
Opération76272934?

Somme partielle : 7 + 6 + 2 + 7 + 2 + 9 + 3 + 4 = 40

Clé = (10 - (40 mod 10)) mod 10 = (10 - 0) mod 10 = 0

SIREN complet : 732 829 320

Implémentation en code

Voici des exemples d'implémentation de la validation SIREN/SIRET dans différents langages de programmation :

JavaScript

function validateSIREN(siren) {
    if (!/^\d{9}$/.test(siren)) return false;
    
    let sum = 0;
    for (let i = 0; i < 9; i++) {
        let digit = parseInt(siren[i]);
        if (i % 2 === 1) {  // Position paire (index impair)
            digit *= 2;
            if (digit > 9) digit -= 9;
        }
        sum += digit;
    }
    return sum % 10 === 0;
}

function validateSIRET(siret) {
    if (!/^\d{14}$/.test(siret)) return false;
    
    // Exception La Poste
    if (siret.startsWith('356000000')) return true;
    
    let sum = 0;
    for (let i = 0; i < 14; i++) {
        let digit = parseInt(siret[i]);
        if (i % 2 === 0) {  // Position impaire (index pair)
            digit *= 2;
            if (digit > 9) digit -= 9;
        }
        sum += digit;
    }
    return sum % 10 === 0;
}

Python

def validate_siren(siren: str) -> bool:
    if not siren.isdigit() or len(siren) != 9:
        return False
    
    total = 0
    for i, char in enumerate(siren):
        digit = int(char)
        if i % 2 == 1:  # Position paire
            digit *= 2
            if digit > 9:
                digit -= 9
        total += digit
    
    return total % 10 == 0

def validate_siret(siret: str) -> bool:
    if not siret.isdigit() or len(siret) != 14:
        return False
    
    # Exception La Poste
    if siret.startswith('356000000'):
        return True
    
    total = 0
    for i, char in enumerate(siret):
        digit = int(char)
        if i % 2 == 0:  # Position impaire
            digit *= 2
            if digit > 9:
                digit -= 9
        total += digit
    
    return total % 10 == 0

Limites de la validation de format

La validation du format est une étape utile mais insuffisante pour confirmer l'existence d'une entreprise :

Ce que la validation détecte ✓

  • Erreurs de frappe
  • Inversions de chiffres
  • Longueur incorrecte
  • Caractères invalides

Ce que la validation ne détecte pas ✗

  • Numéros jamais attribués
  • Entreprises radiées
  • Usurpation d'identité
  • Correspondance nom/numéro

Pour une vérification complète, il est indispensable de consulter les bases de données officielles (sirene.fr, infogreffe.fr) après avoir validé le format.

Tester un numéro Guide SIREN