Générez des numéros de CNPJ brésiliens valides et validez ceux existants avec cet outil simple conçu pour les développeurs et les testeurs travaillant avec les identifiants d'entreprise brésiliens.
Générez un numéro CNPJ brésilien valide à des fins de test.
Vérifiez si un numéro CNPJ brésilien est valide.
Le CNPJ brésilien (Cadastro Nacional da Pessoa Jurídica) est un numéro d'identification unique attribué aux entreprises et entités légales au Brésil. Cet outil de générateur et de validateur de CNPJ brésilien fournit un moyen simple et efficace de générer des numéros de CNPJ valides à des fins de test et de valider les numéros de CNPJ existants selon l'algorithme officiel brésilien. Que vous soyez un développeur testant des applications qui gèrent des données d'entreprises brésiliennes, un professionnel de l'assurance qualité créant des cas de test, ou toute personne travaillant avec des informations d'entreprises brésiliennes, cet outil simplifie le processus de travail avec les numéros de CNPJ.
Contrairement aux numéros de CNPJ réels qui sont officiellement délivrés par la Receita Federal (Administration Fédérale des Recettes) brésilienne, les CNPJ générés par cet outil sont mathématiquement valides mais ne sont pas enregistrés auprès d'entreprises réelles. Cela les rend parfaits pour des scénarios de test, des données d'exemple et des environnements de développement où vous avez besoin de numéros de CNPJ correctement formatés et valides sans utiliser de véritables identifiants d'entreprise.
Un CNPJ (Cadastro Nacional da Pessoa Jurídica) est un numéro d'identification à 14 chiffres attribué aux entreprises et entités légales par la Receita Federal brésilienne. Il sert d'équivalent brésilien d'un numéro d'enregistrement d'entreprise ou d'identifiant fiscal. Chaque entreprise opérant légalement au Brésil doit avoir un CNPJ, qui est utilisé pour :
Le CNPJ est un identifiant essentiel dans l'écosystème commercial brésilien et apparaît sur les documents officiels, les contrats et les dossiers financiers.
Un CNPJ brésilien se compose de 14 chiffres, généralement formatés comme : XX.XXX.XXX/YYYY-ZZ
La structure se décompose comme suit :
Par exemple, un CNPJ correctement formaté pourrait ressembler à : 12.345.678/0001-95
Les chiffres de contrôle (les deux derniers chiffres) sont calculés à l'aide d'un algorithme mathématique spécifique qui valide l'authenticité du CNPJ. Cet algorithme garantit que les numéros générés aléatoirement ne peuvent pas passer la validation sans suivre la méthode de calcul appropriée.
L'algorithme de validation du CNPJ utilise un calcul pondéré pour déterminer les chiffres de contrôle. Voici comment cela fonctionne :
Pour qu'un CNPJ soit valide, les deux chiffres de contrôle doivent correspondre aux valeurs calculées.
Notre outil de Générateur et Validateur de CNPJ brésilien offre deux fonctions principales : générer des CNPJ valides et valider des numéros de CNPJ existants.
Pour générer un CNPJ valide à des fins de test :
Le CNPJ généré suivra toutes les règles de validation mathématique d'un véritable CNPJ mais n'est pas enregistré auprès de la Receita Federal brésilienne.
Pour vérifier si un CNPJ est mathématiquement valide :
Le validateur vérifie si le CNPJ suit le format correct et si les chiffres de contrôle correspondent aux valeurs attendues selon l'algorithme de validation.
Cet outil de générateur et de validateur de CNPJ brésilien est particulièrement utile dans les scénarios suivants :
Bien que notre outil fournisse une solution simple basée sur le navigateur pour générer et valider des CNPJ, il existe plusieurs alternatives en fonction de vos besoins spécifiques :
Pour les développeurs intégrant la validation de CNPJ directement dans des applications, plusieurs bibliothèques spécifiques aux langages sont disponibles :
cpf_cnpj.js, validator.jspython-cnpj, validate-docbrbrazilianutils, respect/validationcaelum-stella, commons-validatorcpf_cnpj, brazilian-railsCes bibliothèques offrent souvent des fonctionnalités supplémentaires comme le formatage, l'analyse et la validation d'autres documents brésiliens.
Pour les applications nécessitant une validation sans implémenter l'algorithme :
À des fins éducatives ou pour des validations ponctuelles, vous pouvez appliquer manuellement l'algorithme :
Cependant, le calcul manuel est sujet à des erreurs et inefficace pour un usage régulier.
Le générateur et le validateur de CNPJ dans cet outil sont implémentés en JavaScript, ce qui le rend rapide et capable de fonctionner entièrement dans votre navigateur sans envoyer vos données à un serveur. Voici comment fonctionnent les fonctions principales :
1function generateCNPJ() {
2 // Générer les 12 premiers chiffres aléatoirement
3 const digits = Array.from({ length: 12 }, () => Math.floor(Math.random() * 10));
4
5 // Calculer le premier chiffre de contrôle
6 const firstCheckDigit = calculateCheckDigit(digits);
7 digits.push(firstCheckDigit);
8
9 // Calculer le deuxième chiffre de contrôle
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}
291function validateCNPJ(cnpj) {
2 // Supprimer les caractères non numériques
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Vérifier s'il a la bonne longueur
6 if (cleanCNPJ.length !== 14) return false;
7
8 // Vérifier les motifs connus invalides (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 vérification
15 const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16 if (digits[12] !== expectedFirstDigit) return false;
17
18 // Vérifier le deuxième chiffre de vérification
19 const expectedSecondDigit = calculateCheckDigit(digits.slice(0, 13));
20 if (digits[13] !== expectedSecondDigit) return false;
21
22 return true;
23}
241function formatCNPJ(cnpj) {
2 // Supprimer les caractères non numériques
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Formater selon 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}
18Ces fonctions principales peuvent être implémentées dans d'autres langages de programmation en suivant la même logique. Voici des exemples en Python et Java :
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 aléatoirement
15 digits = [random.randint(0, 9) for _ in range(12)]
16
17 # Calculer le premier chiffre de contrôle
18 first_check = calculate_check_digit(digits)
19 digits.append(first_check)
20
21 # Calculer le deuxième chiffre de contrôle
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 les mêmes
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
551import 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 aléatoirement
10 for (int i = 0; i < 12; i++) {
11 digits[i] = random.nextInt(10);
12 }
13
14 // Calculer le premier chiffre de contrôle
15 digits[12] = calculateCheckDigit(digits, 12);
16
17 // Calculer le deuxième chiffre de contrôle
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 les mêmes
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}
85Lorsque vous utilisez cet outil de générateur et de validateur de CNPJ, gardez à l'esprit les considérations suivantes :
Un CNPJ est le numéro d'enregistrement national pour les entreprises et entités légales au Brésil. Il est utilisé à des fins fiscales, d'enregistrement d'entreprise, d'ouverture de comptes bancaires et d'identification des entreprises dans les transactions officielles.
Non. Les CNPJ générés par cet outil sont mathématiquement valides selon l'algorithme de chiffre de contrôle, mais ils ne sont pas enregistrés auprès de la Receita Federal brésilienne et n'appartiennent pas à de véritables entreprises.
Non. Pour obtenir un CNPJ légitime pour une entreprise, vous devez vous enregistrer auprès de la Receita Federal brésilienne en suivant le processus officiel. Les CNPJ générés ne sont destinés qu'à des fins de test.
Pour vérifier si un CNPJ est enregistré à une entreprise réelle, vous devez consulter la base de données de la Receita Federal brésilienne. Notre outil vérifie uniquement si un CNPJ est mathématiquement valide, pas s'il est officiellement enregistré.
Les CNPJ avec tous les mêmes chiffres (comme 11.111.111/1111-11) sont automatiquement considérés comme invalides, même s'ils passent mathématiquement l'algorithme de chiffre de contrôle. C'est une règle établie par la Receita Federal brésilienne.
Non. Tout le traitement se fait dans votre navigateur, et nous ne stockons ni ne transmettons aucun des CNPJ que vous générez ou validez.
La version actuelle de l'outil génère un CNPJ à la fois. Pour une génération en masse, vous voudrez peut-être envisager d'utiliser l'une des bibliothèques de programmation mentionnées dans la section Alternatives.
C'est le format officiel requis par les autorités brésiliennes. Le regroupement spécifique aide à identifier les différents composants du CNPJ, tels que le numéro de base et l'identifiant de la succursale.
Vous pouvez implémenter l'algorithme de validation dans votre langage de programmation préféré en utilisant les exemples de code fournis dans la section Mise en Œuvre Technique, ou utiliser l'une des bibliothèques mentionnées dans la section Alternatives.
Oui. Les entités gouvernementales au Brésil ont des motifs de CNPJ spécifiques. Par exemple, les entités gouvernementales fédérales commencent souvent par des chiffres spécifiques. Notre générateur crée des CNPJ aléatoires et ne génère pas spécifiquement de CNPJ pour les entités gouvernementales.
Notre outil de Générateur et Validateur de CNPJ brésilien rend le travail avec ces numéros d'identification simple et efficace. Que vous testiez des applications, prépariez des données d'exemple ou validiez des CNPJ existants, cet outil fournit une solution directe sans la complexité des intégrations API ou des configurations avancées.
Générez votre premier CNPJ valide maintenant ou validez-en un existant en utilisant notre interface simple !
Découvrez plus d'outils qui pourraient être utiles pour votre flux de travail