Genera números de CNPJ brasiler vàlids i valida'n els existents amb aquesta eina senzilla dissenyada per a desenvolupadors i provadors que treballen amb identificadors d'empreses brasileres.
Genera un número de CNPJ brasiler vàlid per a fins de prova.
Comprova si un número de CNPJ brasiler és vàlid.
El CNPJ brasiler (Cadastro Nacional da Pessoa Jurídica) és un número d'identificació únic assignat a empreses i entitats legals al Brasil. Aquesta eina de generació i validació de CNPJ brasiler proporciona una manera senzilla i eficient de generar números de CNPJ vàlids per a fins de prova i validar números de CNPJ existents d'acord amb l'algorisme oficial brasiler. Tant si sou un desenvolupador que prova aplicacions que gestionen dades empresarials brasileres, un professional de QA que crea casos de prova, o qualsevol persona que treballi amb informació d'empreses brasileres, aquesta eina simplifica el procés de treballar amb números de CNPJ.
A diferència dels números de CNPJ reals que són emesos oficialment pel Servei Federal d'Hisenda brasiler (Receita Federal), els CNPJ generats per aquesta eina són matemàticament vàlids però no estan registrats a empreses reals. Això els fa perfectes per a escenaris de prova, dades d'exemple i entorns de desenvolupament on necessiteu números de CNPJ correctament formats i vàlids sense utilitzar identificadors d'empreses reals.
Un CNPJ (Cadastro Nacional da Pessoa Jurídica) és un número d'identificació de 14 dígits assignat a empreses i entitats legals pel Servei Federal d'Hisenda brasiler. Serveix com l'equivalent brasiler d'un número d'inscripció d'empresa o d'ID fiscal. Cada empresa que opera legalment al Brasil ha de tenir un CNPJ, que s'utilitza per a:
El CNPJ és un identificador essencial en l'ecosistema empresarial brasiler i apareix en documents oficials, contractes i registres financers.
Un CNPJ brasiler consisteix en 14 dígits, normalment formatats com: XX.XXX.XXX/YYYY-ZZ
L'estructura es desglossa de la següent manera:
Per exemple, un CNPJ correctament format podria semblar: 12.345.678/0001-95
Els dígits de control (els dos últims números) es calculen mitjançant un algorisme matemàtic específic que valida l'autenticitat del CNPJ. Aquest algorisme assegura que els números generats aleatòriament no poden passar la validació sense seguir el mètode de càlcul adequat.
L'algorisme de validació del CNPJ utilitza un càlcul ponderat per determinar els dígits de control. Així és com funciona:
Perquè un CNPJ sigui vàlid, ambdós dígits de control han de coincidir amb els valors calculats.
La nostra eina de generador i validador de CNPJ brasiler ofereix dues funcions principals: generar CNPJs vàlids i validar números de CNPJ existents.
Per generar un CNPJ vàlid per a fins de prova:
El CNPJ generat seguirà totes les regles de validació matemàtica d'un CNPJ real però no està registrat amb el Servei Federal d'Hisenda brasiler.
Per comprovar si un CNPJ és matemàticament vàlid:
El validador comprova si el CNPJ segueix el format correcte i si els dígits de control coincideixen amb els valors esperats d'acord amb l'algorisme de validació.
Aquesta eina de generador i validador de CNPJ brasiler és particularment útil en els següents escenaris:
Si bé la nostra eina proporciona una solució senzilla basada en el navegador per generar i validar CNPJs, hi ha diverses alternatives segons les vostres necessitats específiques:
Per a desenvolupadors que integren la validació de CNPJ directament a les aplicacions, hi ha diverses llibreries específiques per a llenguatges disponibles:
cpf_cnpj.js, validator.jspython-cnpj, validate-docbrbrazilianutils, respect/validationcaelum-stella, commons-validatorcpf_cnpj, brazilian-railsAquestes llibreries sovint proporcionen funcionalitat addicional com ara formatatge, anàlisi i validació d'altres documents brasilers.
Per a aplicacions que requereixen validació sense implementar l'algorisme:
Per a fins educatius o validacions puntuals, podeu aplicar manualment l'algorisme:
Tanmateix, el càlcul manual és propens a errors i ineficient per a un ús regular.
El generador i validador de CNPJ en aquesta eina s'implementa mitjançant JavaScript, cosa que el fa ràpid i capaç d'executar-se completament al vostre navegador sense enviar les vostres dades a un servidor. Així és com funcionen les funcions principals:
1function generateCNPJ() {
2 // Generar els primers 12 dígits aleatòriament
3 const digits = Array.from({ length: 12 }, () => Math.floor(Math.random() * 10));
4
5 // Calcular el primer dígit de control
6 const firstCheckDigit = calculateCheckDigit(digits);
7 digits.push(firstCheckDigit);
8
9 // Calcular el segon dígit de control
10 const secondCheckDigit = calculateCheckDigit(digits);
11 digits.push(secondCheckDigit);
12
13 // Format del 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 // Eliminar caràcters no numèrics
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Comprovar si té la longitud correcta
6 if (cleanCNPJ.length !== 14) return false;
7
8 // Comprovar patrons invàlids coneguts (tots els mateixos dígits)
9 if (/^(\d)\1+$/.test(cleanCNPJ)) return false;
10
11 // Convertir a una matriu de dígits
12 const digits = cleanCNPJ.split('').map(Number);
13
14 // Comprovar el primer dígit de validació
15 const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16 if (digits[12] !== expectedFirstDigit) return false;
17
18 // Comprovar el segon dígit de validació
19 const expectedSecondDigit = calculateCheckDigit(digits.slice(0, 13));
20 if (digits[13] !== expectedSecondDigit) return false;
21
22 return true;
23}
241function formatCNPJ(cnpj) {
2 // Eliminar caràcters no numèrics
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Format segons la longitud
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}
18Aquestes funcions principals es poden implementar en altres llenguatges de programació seguint la mateixa lògica. Aquí teniu exemples en Python i 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 # Generar els primers 12 dígits aleatòriament
15 digits = [random.randint(0, 9) for _ in range(12)]
16
17 # Calcular el primer dígit de control
18 first_check = calculate_check_digit(digits)
19 digits.append(first_check)
20
21 # Calcular el segon dígit de control
22 second_check = calculate_check_digit(digits)
23 digits.append(second_check)
24
25 # Format del 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 # Eliminar caràcters no numèrics
31 cnpj = ''.join(filter(str.isdigit, cnpj))
32
33 # Comprovar longitud
34 if len(cnpj) != 14:
35 return False
36
37 # Comprovar si tots els dígits són els mateixos
38 if len(set(cnpj)) == 1:
39 return False
40
41 # Convertir a una llista d'enters
42 digits = [int(d) for d in cnpj]
43
44 # Validar el primer dígit de control
45 first_check = calculate_check_digit(digits[:12])
46 if digits[12] != first_check:
47 return False
48
49 # Validar el segon dígit de control
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 // Generar els primers 12 dígits aleatòriament
10 for (int i = 0; i < 12; i++) {
11 digits[i] = random.nextInt(10);
12 }
13
14 // Calcular el primer dígit de control
15 digits[12] = calculateCheckDigit(digits, 12);
16
17 // Calcular el segon dígit de control
18 digits[13] = calculateCheckDigit(digits, 13);
19
20 // Format del 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 // Eliminar caràcters no numèrics
45 cnpj = cnpj.replaceAll("\\D", "");
46
47 // Comprovar longitud
48 if (cnpj.length() != 14) {
49 return false;
50 }
51
52 // Comprovar si tots els dígits són els mateixos
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 a una matriu d'enters
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 // Validar el primer dígit de control
71 int firstCheck = calculateCheckDigit(digits, 12);
72 if (digits[12] != firstCheck) {
73 return false;
74 }
75
76 // Validar el segon dígit de control
77 int secondCheck = calculateCheckDigit(digits, 13);
78 if (digits[13] != secondCheck) {
79 return false;
80 }
81
82 return true;
83 }
84}
85Quan utilitzeu aquesta eina generadora i validadora de CNPJ, tingueu en compte les següents consideracions:
Un CNPJ és el número d'inscripció nacional per a empreses i entitats legals al Brasil. S'utilitza per a fins fiscals, inscripció d'empreses, obertura de comptes bancaris i identificació d'empreses en transaccions oficials.
No. Els CNPJ generats per aquesta eina són matemàticament vàlids d'acord amb l'algorisme dels dígits de control, però no estan registrats amb el Servei Federal d'Hisenda brasiler i no pertanyen a empreses reals.
No. Per obtenir un CNPJ legítim per a una empresa, heu de registrar-vos amb el Servei Federal d'Hisenda brasiler (Receita Federal) seguint el procés oficial. Els CNPJ generats són només per a proves.
Per verificar si un CNPJ està registrat a una empresa real, necessiteu consultar la base de dades del Servei Federal d'Hisenda brasiler. La nostra eina només comprova si un CNPJ és matemàticament vàlid, no si està registrat oficialment.
Els CNPJ amb tots els mateixos dígits (com 11.111.111/1111-11) es consideren automàticament invàlids, fins i tot si matemàticament passen l'algorisme dels dígits de control. Aquesta és una regla establerta pel Servei Federal d'Hisenda brasiler.
No. Tot el processament es realitza al vostre navegador, i no emmagatzemem ni transmetem cap dels CNPJ que genereu o valideu.
La versió actual de l'eina genera un CNPJ a la vegada. Per a generació massiva, potser voldreu considerar utilitzar una de les llibreries de programació esmentades a la secció Alternatives.
Aquest és el format oficial requerit per les autoritats brasileres. El grupament específic ajuda a identificar diferents components del CNPJ, com ara el número base i l'identificador de sucursal.
Podeu implementar l'algorisme de validació en el vostre llenguatge de programació preferit utilitzant els exemples de codi proporcionats a la secció d'Implementació tècnica, o utilitzar una de les llibreries esmentades a la secció Alternatives.
Sí. Les entitats governamentals al Brasil tenen patrons de CNPJ específics. Per exemple, les entitats governamentals federals sovint comencen amb dígits específics. El nostre generador crea CNPJs aleatoris i no genera específicament CNPJs d'entitats governamentals.
La nostra eina de generador i validador de CNPJ brasiler fa que treballar amb aquests números d'identificació sigui senzill i eficient. Tant si esteu provant aplicacions, preparant dades d'exemple o validant CNPJs existents, aquesta eina proporciona una solució senzilla sense la complexitat de les integracions d'API o configuracions avançades.
Genera el teu primer CNPJ vàlid ara o valida'n un existent utilitzant la nostra interfície senzilla!
Descobreix més eines que podrien ser útils per al teu flux de treball