Passer au contenu
🛠️
Whiz Tools

Générateur et Validateur CNPJ - Outil d'Identification d'Entreprise Brésilienne

Générez des numéros CNPJ valides pour les tests ou validez instantanément des identifiants d'entreprises brésiliennes. Outil gratuit avec vérification des chiffres de contrôle pour les développeurs travaillant avec le Cadastro Nacional da Pessoa Jurídica.

Générateur et Validateur de CNPJ Brésilien

Générateur de CNPJ

Générer un numéro de CNPJ brésilien valide à des fins de test.

Validateur de CNPJ

Vérifier si un numéro de CNPJ brésilien est valide.

Calculateur de chargement...
📚

Documentation

Comprendre les numéros CNPJ brésiliens

Le CNPJ (Cadastro Nacional da Pessoa Jurídica) est la version brésilienne d'un identifiant fiscal d'entreprise — un numéro à 14 chiffres qui identifie chaque entité commerciale légale du pays. Si vous développez un logiciel qui traite des données commerciales brésiliennes, vous rencontrerez rapidement ces numéros dans les formulaires d'inscription, les factures et les intégrations d'API.

Voici ce qui rend cet outil pratique : il génère des CNPJ mathématiquement valides pour les tests sans utiliser des identifiants d'entreprises réels. Lorsque vous configurez une base de données de test avec 1 000 enregistrements ou que vous déboguez une routine de validation à 2 heures du matin, vous avez besoin de CNPJ qui passent les vérifications algorithmiques mais ne correspondent pas accidentellement à des entreprises réelles. C'est exactement ce que cet outil génère.

Les numéros créés ici suivent l'algorithme de validation officiel de la Receita Federal (Service des Recettes Fédérales brésilien). Ils ont des chiffres de contrôle corrects et un formatage approprié — ils ne sont simplement pas enregistrés dans la base de données gouvernementale. Considérez-les comme des données de test syntaxiquement correctes qui ne créeront pas de problèmes de conformité dans votre environnement de développement.

Qu'est-ce qu'un CNPJ et pourquoi c'est important

Un CNPJ sert d'identifiant d'entreprise au Brésil — similaire à un EIN aux États-Unis ou à un numéro d'enregistrement d'entreprise au Royaume-Uni. Chaque entité commerciale opérant légalement au Brésil doit en posséder un, délivré par la Receita Federal (Service des Revenus Fédéraux).

Vous rencontrerez des CNPJ lors de :

  • Traitement des paiements : Les passerelles de paiement brésiliennes exigent une validation CNPJ pour les comptes de commerçants
  • Conformité fiscale : Chaque facture émise au Brésil doit inclure un CNPJ valide
  • Enregistrement d'entreprise : Les agences gouvernementales utilisent les CNPJ pour suivre les entités juridiques dans différents systèmes
  • Opérations bancaires : Ouverture de comptes d'entreprise ou traitement de transferts internationaux
  • Import/export : La documentation douanière nécessite une vérification CNPJ
  • Contrats gouvernementaux : Les systèmes d'appels d'offres publics valident les CNPJ avant d'accepter les soumissions

D'après mon expérience avec les plateformes de commerce électronique brésiliennes, l'un des points d'intégration les plus courants est le flux de paiement où les utilisateurs saisissent leur CNPJ pour des achats d'entreprise. Votre logique de validation doit intercepter les erreurs de formatage avant le processeur de paiement — sinon vous verrez des transactions échouer qui auraient pu être évitées.

Structure et Format du CNPJ

Un CNPJ est composé de 14 chiffres formatés comme suit : XX.XXX.XXX/YYYY-ZZ

Décomposition de la structure :

  1. Premiers 8 chiffres (XX.XXX.XXX) : Le numéro d'enregistrement de base unique attribué à l'entreprise
  2. 4 chiffres suivants (/YYYY) : Identifiant de succursale ou d'établissement—/0001 indique le siège social, tandis que /0002, /0003 représentent les emplacements de succursales
  3. Derniers 2 chiffres (-ZZ) : Chiffres de vérification calculés via un algorithme pondéré

Exemple : 12.345.678/0001-95

Ce qui est intéressant concernant l'identifiant de succursale : lorsqu'une entreprise ouvre plusieurs emplacements, chacun reçoit les mêmes 8 premiers chiffres mais un numéro de succursale différent. Ainsi, si une chaîne de vente au détail possède 50 magasins, ils auront des CNPJ se terminant par /0001 jusqu'à /0050, partageant tous le même numéro de base. Cela facilite l'identification du fait que plusieurs CNPJ appartiennent à la même organisation mère.

Les chiffres de vérification ne sont pas aléatoires—ils sont calculés à l'aide d'un algorithme de modulo-11 avec des séquences de poids spécifiques. Ce choix de conception, courant dans les documents administratifs brésiliens, rend mathématiquement difficile la falsification de numéros valides ou la création accidentelle de numéros valides par des fautes de frappe.

Comment fonctionne réellement la validation du CNPJ

L'algorithme de validation utilise un calcul de modulo-11 pondéré. Voici la logique derrière :

Calcul du premier chiffre de contrôle

  1. Prendre les 12 premiers chiffres et multiplier chacun par des poids : 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
  2. Additionner tous les produits
  3. Diviser la somme par 11 et obtenir le reste
  4. Si le reste < 2, le chiffre de contrôle est 0 ; sinon, c'est 11 - reste

Calcul du deuxième chiffre de contrôle

  1. Prendre les 13 premiers chiffres (y compris le premier chiffre de contrôle) et multiplier par des poids : 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
  2. Additionner tous les produits
  3. Diviser par 11 et obtenir le reste
  4. Si le reste < 2, le chiffre de contrôle est 0 ; sinon, c'est 11 - reste

Pourquoi cette approche fonctionne : Le système de multiplication pondérée crée une relation unique entre tous les 12 chiffres de base et les chiffres de contrôle résultants. Changer même un seul chiffre dans le nombre de base produit des chiffres de contrôle différents, ce qui permet de détecter les erreurs courantes de transcription comme l'inversion de deux chiffres (taper 12.345 au lieu de 12.354).

Une note pratique : Les CNPJ avec tous les chiffres identiques (comme 11.111.111/1111-11) sont automatiquement invalides, même s'ils passent la vérification mathématique. La Receita Federal exclut explicitement ces modèles pour éviter les cas triviaux.

Comment utiliser le Générateur et Validateur de CNPJ

Génération de CNPJs de test

Besoin d'un CNPJ valide pour votre base de données de test ? Voici comment :

  1. Cliquez sur "Générer CNPJ"
  2. L'outil crée un numéro mathématiquement valide instantanément
  3. Cliquez sur "Copier" pour le mettre dans votre presse-papiers
  4. Collez-le dans vos formulaires de test, vos seeds de base de données ou vos tests unitaires

Chaque CNPJ généré passe tous les contrôles de validation algorithmique mais n'est pas enregistré auprès de la Receita Federal. Cela signifie que vous pouvez les utiliser librement en développement sans vous inquiéter d'utiliser accidentellement l'identifiant d'une entreprise réelle.

Validation des numéros de CNPJ

Vous avez un CNPJ à vérifier ? Le validateur s'en charge :

  1. Collez ou saisissez le CNPJ dans le champ de saisie
  2. Ne vous inquiétez pas du formatage — il fonctionne avec 12345678000195 ou 12.345.678/0001-95
  3. Cliquez sur "Valider"
  4. Obtenez un retour instantané sur la validité des chiffres de contrôle

Ce que le validateur vérifie : longueur appropriée (14 chiffres), calculs corrects des chiffres de contrôle et exclusion des motifs invalides comme les chiffres identiques. Ce qu'il ne vérifie pas : si le CNPJ est enregistré dans la base de données gouvernementale — cela nécessite une requête directe auprès de la Receita Federal.

Cas d'utilisation réels du générateur et validateur de CNPJ

Développement logiciel et tests

Alimentation de base de données : Lors de la configuration d'un environnement de staging avec des données de test réalistes, vous avez besoin de dizaines ou de centaines de CNPJ valides. La création manuelle est fastidieuse, et l'utilisation d'identifiants d'entreprises réels soulève des problèmes de confidentialité. Les CNPJ générés résolvent ces deux problèmes.

Tests unitaires de cas limites : Votre fonction de validation doit rejeter 00.000.000/0000-00 mais accepter 11.222.333/0001-81. Disposer d'un générateur vous permet de créer rapidement des cas de test à la fois valides et intentionnellement invalides pour vérifier que votre logique gère correctement les conditions limites.

Tests de régression QA : Lors des tests de formulaires d'inscription ou de flux de paiement B2B, les équipes QA ont besoin de nouvelles données de test à chaque exécution. Un problème courant que j'ai observé : les environnements de test se retrouvent pollués avec les mêmes 5-6 CNPJ utilisés de manière répétée, ce qui masque les bugs qui n'apparaissent qu'avec des motifs de chiffres spécifiques.

Tests d'intégration d'API : Si vous intégrez des processeurs de paiement brésiliens comme PagSeguro ou Mercado Pago, leurs environnements de test requièrent souvent un formatage CNPJ valide. Les calculs doivent être corrects même si vous n'accédez pas aux bases de données de production.

Traitement et validation de données

Nettoyage de données importées : Vous avez reçu un CSV avec 10 000 enregistrements d'entreprises brésiliennes. Avant le traitement, vous devez identifier les CNPJ malformés. En les faisant passer par le validateur, vous identifiez les entrées avec des fautes de frappe, des troncatures ou des chiffres de contrôle incorrects — économisant des heures de débogage.

Validation de formulaire côté client : Détecter les CNPJ invalides avant la soumission du formulaire améliore l'expérience utilisateur. Personne ne veut remplir un formulaire d'inscription de 20 champs pour obtenir une erreur à la soumission parce qu'il a inversé deux chiffres de son CNPJ.

Anonymisation de données pour l'analyse : Lors de la préparation de données de production à partager avec des équipes d'analyse ou des partenaires externes, vous devez remplacer les CNPJ réels par des CNPJ valides mais fictifs. Cela maintient l'intégrité référentielle de votre jeu de données tout en protégeant les identités d'entreprises réelles.

Opérations commerciales internationales

Comprendre les exigences brésiliennes : Si vous vous développez sur le marché brésilien, vous rencontrerez des exigences de CNPJ dans les contrats, les factures et la documentation d'expédition. Disposer d'un outil pour expérimenter le format vous aide à comprendre ce que vos systèmes doivent gérer.

Spécifications d'intégration tierces : Lors de l'examen de la documentation API de fournisseurs SaaS brésiliens, vous verrez souvent des champs CNPJ dans les exemples de charges utiles. Pouvoir générer des valeurs de test valides vous aide à prototyper des intégrations plus rapidement.

Approches alternatives de validation du CNPJ

Bibliothèques de programmation

Si vous avez besoin d'une validation CNPJ intégrée à la logique de votre application, ces bibliothèques implémentent l'algorithme de vérification du chiffre de contrôle :

Ces bibliothèques gèrent généralement le formatage, l'analyse et la validation de plusieurs types de documents brésiliens (CPF, CNPJ, etc.).

API de vérification officielles

Pour les systèmes de production qui doivent vérifier l'enregistrement commercial réel :

  • Service public de la Receita Federal : L'API Consulta CNPJ permet la vérification par rapport à la base de données officielle (nécessite une autorisation appropriée et une limitation du taux)
  • Fournisseurs de données tiers : Des services comme Serasa Experian et Boa Vista SCPC offrent des API commerciales qui renvoient les détails de l'entreprise, le statut d'enregistrement et les informations de crédit

Remarque : Ces services vérifient l'enregistrement réel, pas seulement la validité mathématique. Vous aurez besoin d'une autorisation appropriée et devez vous attendre à des coûts d'API pour une utilisation en production.

Quand utiliser chaque approche

Utilisez cet outil de navigateur quand : Vous avez besoin d'une validation rapide sans installer de dépendances, générer des données de test pour des démos ou comprendre comment fonctionne la validation CNPJ.

Utilisez une bibliothèque quand : Vous développez une application qui nécessite une validation côté client ou serveur dans le cadre du traitement de formulaire.

Utilisez une API officielle quand : Vous devez vérifier qu'un CNPJ correspond à une entité commerciale réelle et active avec un statut d'enregistrement actuel.

Détails techniques de mise en œuvre

Cet outil fonctionne entièrement dans votre navigateur en utilisant JavaScript—aucune requête serveur, aucune donnée quittant votre machine. Voici comment fonctionnent les algorithmes sous le capot, avec du code que vous pouvez adapter pour vos propres projets :

Algorithme de génération de CNPJ

1function generateCNPJ() {
2  // Générer les 12 premiers chiffres de manière aléatoire
3  const digits = Array.from({ length: 12 }, () => Math.floor(Math.random() * 10));
4  
5  // Calculer le premier chiffre de vérification
6  const firstCheckDigit = calculateCheckDigit(digits);
7  digits.push(firstCheckDigit);
8  
9  // Calculer le deuxième chiffre de vérification
10  const secondCheckDigit = calculateCheckDigit(digits);
11  digits.push(secondCheckDigit);
12  
13  // Formater le CNPJ
14  return formatCNPJ(digits.join(''));
15}
16
17function calculateCheckDigit(digits) {
18  const weights = digits.length < 13 
19    ? [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2] 
20    : [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
21  
22  const sum = digits.reduce((acc, digit, index) => {
23    return acc + digit * weights[index];
24  }, 0);
25  
26  const remainder = sum % 11;
27  return remainder < 2 ? 0 : 11 - remainder;
28}
29

Algorithme de validation de CNPJ

1function validateCNPJ(cnpj) {
2  // Supprimer les caractères non numériques
3  const cleanCNPJ = cnpj.replace(/\D/g, '');
4  
5  // Vérifier si la longueur est correcte
6  if (cleanCNPJ.length !== 14) return false;
7  
8  // Vérifier les motifs invalides connus (tous les mêmes chiffres)
9  if (/^(\d)\1+$/.test(cleanCNPJ)) return false;
10  
11  // Convertir en tableau de chiffres
12  const digits = cleanCNPJ.split('').map(Number);
13  
14  // Vérifier le premier chiffre de contrôle
15  const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16  if (digits[12] !== expectedFirstDigit) return false;
17  
18  // Vérifier le deuxième chiffre de contrôle
19  const expectedSecondDigit = calculateCheckDigit(digits.slice(0, 13));
20  if (digits[13] !== expectedSecondDigit) return false;
21  
22  return true;
23}
24

Fonction de formatage de CNPJ

1function formatCNPJ(cnpj) {
2  // Supprimer les caractères non numériques
3  const cleanCNPJ = cnpj.replace(/\D/g, '');
4  
5  // Formater en fonction de la longueur
6  if (cleanCNPJ.length <= 2) {
7    return cleanCNPJ;
8  } else if (cleanCNPJ.length <= 5) {
9    return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2)}`;
10  } else if (cleanCNPJ.length <= 8) {
11    return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2, 5)}.${cleanCNPJ.slice(5)}`;
12  } else if (cleanCNPJ.length <= 12) {
13    return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2, 5)}.${cleanCNPJ.slice(5, 8)}/${cleanCNPJ.slice(8)}`;
14  } else {
15    return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2, 5)}.${cleanCNPJ.slice(5, 8)}/${cleanCNPJ.slice(8, 12)}-${cleanCNPJ.slice(12, 14)}`;
16  }
17}
18

Ces fonctions de base peuvent être implémentées dans d'autres langages de programmation en suivant la même logique. Voici des exemples en Python et en Java :

Implémentation Python

1import random
2
3def calculate_check_digit(digits):
4    weights = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2] if len(digits) < 13 else [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
5    
6    total = 0
7    for i in range(len(digits)):
8        total += digits[i] * weights[i]
9    
10    remainder = total % 11
11    return 0 if remainder < 2 else 11 - remainder
12
13def generate_cnpj():
14    # Générer les 12 premiers chiffres de manière aléatoire
15    digits = [random.randint(0, 9) for _ in range(12)]
16    
17    # Calculer le premier chiffre de vérification
18    first_check = calculate_check_digit(digits)
19    digits.append(first_check)
20    
21    # Calculer le deuxième chiffre de vérification
22    second_check = calculate_check_digit(digits)
23    digits.append(second_check)
24    
25    # Formater le CNPJ
26    cnpj = ''.join(map(str, digits))
27    return f"{cnpj[:2]}.{cnpj[2:5]}.{cnpj[5:8]}/{cnpj[8:12]}-{cnpj[12:]}"
28
29def validate_cnpj(cnpj):
30    # Supprimer les caractères non numériques
31    cnpj = ''.join(filter(str.isdigit, cnpj))
32    
33    # Vérifier la longueur
34    if len(cnpj) != 14:
35        return False
36    
37    # Vérifier si tous les chiffres sont identiques
38    if len(set(cnpj)) == 1:
39        return False
40    
41    # Convertir en liste d'entiers
42    digits = [int(d) for d in cnpj]
43    
44    # Valider le premier chiffre de contrôle
45    first_check = calculate_check_digit(digits[:12])
46    if digits[12] != first_check:
47        return False
48    
49    # Valider le deuxième chiffre de contrôle
50    second_check = calculate_check_digit(digits[:13])
51    if digits[13] != second_check:
52        return False
53    
54    return True
55

Implémentation Java

1import java.util.Random;
2
3public class CNPJUtils {
4    
5    public static String generateCNPJ() {
6        Random random = new Random();
7        int[] digits = new int[14];
8        
9        // Générer les 12 premiers chiffres de manière aléatoire
10        for (int i = 0; i < 12; i++) {
11            digits[i] = random.nextInt(10);
12        }
13        
14        // Calculer le premier chiffre de vérification
15        digits[12] = calculateCheckDigit(digits, 12);
16        
17        // Calculer le deuxième chiffre de vérification
18        digits[13] = calculateCheckDigit(digits, 13);
19        
20        // Formater le CNPJ
21        return String.format("%02d.%03d.%03d/%04d-%02d",
22                digits[0] * 10 + digits[1],
23                digits[2] * 100 + digits[3] * 10 + digits[4],
24                digits[5] * 100 + digits[6] * 10 + digits[7],
25                digits[8] * 1000 + digits[9] * 100 + digits[10] * 10 + digits[11],
26                digits[12] * 10 + digits[13]);
27    }
28    
29    private static int calculateCheckDigit(int[] digits, int length) {
30        int[] weights = length < 13 
31            ? new int[]{5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2}
32            : new int[]{6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2};
33        
34        int sum = 0;
35        for (int i = 0; i < length; i++) {
36            sum += digits[i] * weights[i];
37        }
38        
39        int remainder = sum % 11;
40        return remainder < 2 ? 0 : 11 - remainder;
41    }
42    
43    public static boolean validateCNPJ(String cnpj) {
44        // Supprimer les caractères non numériques
45        cnpj = cnpj.replaceAll("\\D", "");
46        
47        // Vérifier la longueur
48        if (cnpj.length() != 14) {
49            return false;
50        }
51        
52        // Vérifier si tous les chiffres sont identiques
53        boolean allDigitsSame = true;
54        for (int i = 1; i < cnpj.length(); i++) {
55            if (cnpj.charAt(i) != cnpj.charAt(0)) {
56                allDigitsSame = false;
57                break;
58            }
59        }
60        if (allDigitsSame) {
61            return false;
62        }
63        
64        // Convertir en tableau d'entiers
65        int[] digits = new int[14];
66        for (int i = 0; i < 14; i++) {
67            digits[i] = Character.getNumericValue(cnpj.charAt(i));
68        }
69        
70        // Valider le premier chiffre de contrôle
71        int firstCheck = calculateCheckDigit(digits, 12);
72        if (digits[12] != firstCheck) {
73            return false;
74        }
75        
76        // Valider le deuxième chiffre de contrôle
77        int secondCheck = calculateCheckDigit(digits, 13);
78        if (digits[13] != secondCheck) {
79            return false;
80        }
81        
82        return true;
83    }
84}
85

Limitations et Considérations Importantes

Ce que Cet Outil Peut et Ne Peut Pas Faire

Ce qu'il valide : La correction mathématique — si les chiffres de contrôle correspondent au calcul de l'algorithme.

Ce qu'il ne valide pas : Si le CNPJ est enregistré auprès de la Receita Federal, s'il appartient à une entreprise active, ou s'il est associé au nom de l'entreprise que vous attendez.

Pensez-y comme une vérification orthographique versus une vérification des faits. Cet outil vous indique si un CNPJ est "orthographié" correctement selon les règles mathématiques, mais il ne peut pas vous dire si le numéro correspond à une entité commerciale réelle et active.

Utilisation Légale et Éthique

Les CNPJ générés sont uniquement destinés aux tests et au développement. Ils sont mathématiquement valides mais non enregistrés auprès des autorités brésiliennes, ce qui signifie :

  • ✅ Sûr d'utiliser pour : Remplir des bases de données de test, tests unitaires de logique de validation, environnements de QA, exemples de code dans la documentation
  • ❌ Ne jamais utiliser pour : Déclaration fiscale, enregistrement d'entreprise, signature de contrats, traitement de transactions réelles, ou usurpation de l'identité d'une entreprise

Utiliser un faux CNPJ à des fins officielles n'est pas seulement non éthique — c'est illégal selon la loi brésilienne et peut entraîner des accusations de fraude.

Limitations Techniques à Connaître

La génération aléatoire a des implications : L'outil génère les 12 premiers chiffres de manière aléatoire. Les CNPJ réels émis par la Receita Federal suivent des modèles internes liés à la date d'enregistrement, au bureau régional et au type d'entreprise. Les numéros générés ne correspondront pas à ces modèles, ce que des systèmes de validation sophistiqués pourraient signaler.

Pas de validation sémantique : Un format de CNPJ valide ne signifie pas un contexte commercial valide. Par exemple, les entités gouvernementales ont des plages de CNPJ spécifiques — ce générateur pourrait accidentellement en créer un, mais il ne serait pas significatif.

Gestion du format : Le validateur accepte différents formats d'entrée (12345678000195, 12.345.678/0001-95), mais certains systèmes hérités attendent un formatage exact. Testez toujours avec vos exigences d'intégration spécifiques.

Confidentialité et Sécurité

Tout traitement se fait côté client dans votre navigateur. Aucun CNPJ que vous générez ou validez n'est envoyé à des serveurs, enregistré ou stocké. L'outil ne demande, ne traite et ne gère aucune information personnelle.

Questions fréquentes sur la validation du CNPJ

Quelle est la différence entre valider et vérifier un CNPJ ?

La validation vérifie si le numéro est mathématiquement correct—format approprié, chiffres de contrôle corrects, pas de motifs invalides. Cet outil effectue la validation.

La vérification vérifie si le CNPJ est enregistré auprès d'une entreprise réelle dans la base de données de la Receita Federal. La vérification nécessite d'interroger la base de données gouvernementale et n'est pas quelque chose que cet outil fait.

Vous pouvez avoir un CNPJ parfaitement valide qui n'est pas vérifié (comme les numéros de test que cet outil génère), ou un CNPJ invalide qui appartient à une entreprise réelle (parce que quelqu'un a fait une faute de frappe en le saisissant).

Puis-je utiliser des CNPJ générés pour des tests de production ?

Cela dépend de ce que vous entendez par "tests de production". Ils conviennent pour les environnements de préparation, les tests de charge et les contrôles qualité avant le lancement. Mais si "tests de production" signifie tester avec des transactions réelles, des API gouvernementales réelles ou des systèmes financiers réels—alors non, vous avez besoin de CNPJ réellement enregistrés.

Une approche plus sûre : utilisez des CNPJ générés dans des environnements de test isolés, puis passez à un petit ensemble de CNPJ d'entreprises de test réels (que vous contrôlez) lors des tests d'intégration de production.

Pourquoi le validateur rejette 11.111.111/1111-11 ?

Même si un CNPJ avec tous les chiffres identiques peut mathématiquement produire des chiffres de contrôle valides, la Receita Federal exclut explicitement ces motifs. C'est une règle métier, pas une règle mathématique. La même chose s'applique aux motifs séquentiels dans certains systèmes de validation.

C'est similaire à la façon dont de nombreux systèmes rejettent des mots de passe comme "password123" même s'ils répondent aux exigences de longueur—ils sont techniquement valides mais pratiquement inacceptables.

Comment gérer la validation CNPJ dans différentes locales ?

Les entreprises brésiliennes faisant des affaires internationales omettent parfois les caractères de formatage lors de la saisie des CNPJ dans des systèmes étrangers. Votre logique de validation doit supprimer les caractères non numériques avant de vérifier :

1const cleanCNPJ = input.replace(/\D/g, ''); // Supprimer tout sauf les chiffres
2

Acceptez 12.345.678/0001-95, 12345678000195, et 12 345 678 0001 95 comme des entrées équivalentes.

Qu'en est-il de la validation CNPJ vs CPF ?

Le CPF (Cadastro de Pessoas Físicas) est l'identifiant fiscal individuel du Brésil, tandis que le CNPJ est destiné aux entreprises. Ils utilisent des algorithmes de chiffres de contrôle différents et des longueurs différentes (CPF a 11 chiffres, CNPJ a 14 chiffres). Si vous construisez une application brésilienne qui gère les deux, vous aurez besoin de fonctions de validation distinctes—bien que de nombreuses bibliothèques prennent en charge les deux formats.

Un modèle courant : laissez les utilisateurs saisir soit un CPF, soit un CNPJ dans le même champ, puis détectez le type en fonction de la longueur après avoir supprimé les caractères de formatage.

Cela fonctionne-t-il pour les entreprises étrangères opérant au Brésil ?

Les entreprises étrangères opérant au Brésil doivent également obtenir des CNPJ auprès de la Receita Federal. Leurs CNPJ suivent le même format et les mêmes règles de validation que les entreprises nationales. Il n'y a pas de format CNPJ spécial pour les "entreprises étrangères".

Cependant, les entreprises étrangères peuvent avoir des exigences de documentation supplémentaires et des processus d'enregistrement différents—consultez un avocat d'affaires brésilien pour plus de détails.

Puis-je interroger la base de données gouvernementale pour vérifier l'enregistrement CNPJ ?

Oui, la Receita Federal fournit un accès public pour vérifier les informations de base du CNPJ via leur Consulta Pública CNPJ. Vous pouvez rechercher manuellement des CNPJ ou, avec une autorisation appropriée, utiliser leurs API pour un accès programmatique.

Notez qu'une utilisation intensive nécessite un enregistrement et qu'il existe des limites de débit pour empêcher les abus.

À quelle fréquence les CNPJ changent-ils ?

Les CNPJ sont des identifiants permanents qui ne changent pas lorsqu'une entreprise change de nom, d'adresse ou de structure de propriété. Cependant, si une entreprise ferme et se réenregistre plus tard, elle peut recevoir un nouveau CNPJ. Les numéros de succursale (la partie /XXXX) peuvent être ajoutés lorsque les entreprises ouvrent de nouveaux emplacements, mais le numéro de base à 8 chiffres reste constant.

Références et ressources supplémentaires

Sources gouvernementales officielles

  1. Receita Federal do Brasil - Portail officiel - Site officiel du Service fédéral des revenus brésilien avec des services d'enregistrement et de vérification CNPJ
  2. Consulta Pública CNPJ - Recherche publique CNPJ - Service gouvernemental officiel pour vérifier le statut d'enregistrement CNPJ
  3. Instruction normative RFB n° 1863/2018 - Réglementations juridiques régissant l'enregistrement et l'utilisation du CNPJ au Brésil

Normes techniques et documentation

  1. Algorithmes d'arithmétique modulaire - Le calcul du chiffre de contrôle utilise l'arithmétique modulo 11, une approche standard pour les chiffres de validation
  2. ISO/IEC 7064 - Norme internationale pour les systèmes de chiffres de contrôle ayant influencé la conception de validation des documents brésiliens
  3. Code civil brésilien (Loi n° 10.406/2002) - Cadre juridique définissant les classifications d'entités commerciales nécessitant un enregistrement CNPJ

Ressources pour développeurs

  1. Registre de packages NPM - npmjs.com - Dépôt de bibliothèques JavaScript, y compris les validateurs de documents brésiliens
  2. PyPI (Python Package Index) - pypi.org - Bibliothèques Python pour la validation CNPJ et le traitement des documents brésiliens
  3. GitHub - Implémentations open-source de validation CNPJ dans plusieurs langages de programmation

Commencez à Générer et Valider des CNPJs

Que vous construisiez une plateforme de commerce électronique brésilienne, testiez des intégrations de paiement avec Mercado Pago, ou que vous ayez simplement besoin de comprendre comment fonctionne la validation de CNPJ, cet outil vous donne un accès immédiat aux capacités de génération et de validation.

Pas d'installation, pas de clés API, pas de configuration compliquée. Ouvrez simplement votre navigateur et commencez à travailler avec des identifiants d'entreprises brésiliens valides.