Genera números de CNPJ brasileños válidos y valida los existentes con esta herramienta simple diseñada para desarrolladores y testers que trabajan con identificaciones empresariales brasileñas.
Genera un número de CNPJ brasileño válido para fines de prueba.
Verifica si un número de CNPJ brasileño es válido.
El CNPJ brasileño (Cadastro Nacional da Pessoa Jurídica) es un número de identificación único asignado a empresas y entidades legales en Brasil. Esta herramienta generadora y validadora de CNPJ brasileño proporciona una forma simple y eficiente de generar números de CNPJ válidos para fines de prueba y validar números de CNPJ existentes de acuerdo con el algoritmo oficial brasileño. Ya seas un desarrollador que prueba aplicaciones que manejan datos empresariales brasileños, un profesional de QA creando casos de prueba, o cualquier persona que trabaje con información de empresas brasileñas, esta herramienta simplifica el proceso de trabajo con números de CNPJ.
A diferencia de los números de CNPJ reales que son emitidos oficialmente por la Receita Federal do Brasil, los CNPJs generados por esta herramienta son matemáticamente válidos pero no están registrados a empresas reales. Esto los hace perfectos para escenarios de prueba, datos de muestra y entornos de desarrollo donde necesitas números de CNPJ correctamente formateados y válidos sin usar identificadores de empresas reales.
Un CNPJ (Cadastro Nacional da Pessoa Jurídica) es un número de identificación de 14 dígitos asignado a empresas y entidades legales por la Receita Federal do Brasil. Sirve como el equivalente brasileño de un número de registro de empresa o identificación fiscal. Cada empresa que opera legalmente en Brasil debe tener un CNPJ, que se utiliza para:
El CNPJ es un identificador esencial en el ecosistema empresarial de Brasil y aparece en documentos oficiales, contratos y registros financieros.
Un CNPJ brasileño consiste en 14 dígitos, típicamente formateados como: XX.XXX.XXX/YYYY-ZZ
La estructura se desglosa de la siguiente manera:
Por ejemplo, un CNPJ correctamente formateado podría verse así: 12.345.678/0001-95
Los dígitos de verificación (los últimos dos números) se calculan utilizando un algoritmo matemático específico que valida la autenticidad del CNPJ. Este algoritmo asegura que los números generados aleatoriamente no puedan pasar la validación sin seguir el método de cálculo adecuado.
El algoritmo de validación del CNPJ utiliza un cálculo ponderado para determinar los dígitos de verificación. Así es como funciona:
Para que un CNPJ sea válido, ambos dígitos de verificación deben coincidir con los valores calculados.
Nuestra herramienta generadora y validadora de CNPJ brasileño ofrece dos funciones principales: generar CNPJs válidos y validar números de CNPJ existentes.
Para generar un CNPJ válido para fines de prueba:
El CNPJ generado seguirá todas las reglas de validación matemática de un CNPJ real, pero no está registrado en la Receita Federal do Brasil.
Para verificar si un CNPJ es matemáticamente válido:
El validador verifica si el CNPJ sigue el formato correcto y si los dígitos de verificación coinciden con los valores esperados de acuerdo con el algoritmo de validación.
Esta herramienta generadora y validadora de CNPJ brasileño es particularmente útil en los siguientes escenarios:
Si bien nuestra herramienta proporciona una solución simple basada en el navegador para generar y validar CNPJs, hay varias alternativas dependiendo de tus necesidades específicas:
Para desarrolladores que integran la validación de CNPJ directamente en aplicaciones, hay varias bibliotecas específicas de lenguaje disponibles:
cpf_cnpj.js, validator.jspython-cnpj, validate-docbrbrazilianutils, respect/validationcaelum-stella, commons-validatorcpf_cnpj, brazilian-railsEstas bibliotecas a menudo proporcionan funcionalidad adicional como formateo, análisis y validación de otros documentos brasileños.
Para aplicaciones que requieren validación sin implementar el algoritmo:
Para fines educativos o validaciones únicas, puedes aplicar manualmente el algoritmo:
Sin embargo, el cálculo manual es propenso a errores e ineficiente para el uso regular.
El generador y validador de CNPJ en esta herramienta están implementados utilizando JavaScript, lo que lo hace rápido y capaz de ejecutarse completamente en tu navegador sin enviar tus datos a un servidor. Así es como funcionan las funciones principales:
1function generateCNPJ() {
2 // Generar los primeros 12 dígitos aleatoriamente
3 const digits = Array.from({ length: 12 }, () => Math.floor(Math.random() * 10));
4
5 // Calcular el primer dígito de verificación
6 const firstCheckDigit = calculateCheckDigit(digits);
7 digits.push(firstCheckDigit);
8
9 // Calcular el segundo dígito de verificación
10 const secondCheckDigit = calculateCheckDigit(digits);
11 digits.push(secondCheckDigit);
12
13 // Formatear el 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 caracteres no numéricos
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Verificar si tiene la longitud correcta
6 if (cleanCNPJ.length !== 14) return false;
7
8 // Verificar patrones inválidos conocidos (todos los mismos dígitos)
9 if (/^(\d)\1+$/.test(cleanCNPJ)) return false;
10
11 // Convertir a un array de dígitos
12 const digits = cleanCNPJ.split('').map(Number);
13
14 // Verificar el primer dígito de verificación
15 const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16 if (digits[12] !== expectedFirstDigit) return false;
17
18 // Verificar el segundo dígito de verificación
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 caracteres no numéricos
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Formatear según 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}
18Estas funciones principales pueden implementarse en otros lenguajes de programación siguiendo la misma lógica. Aquí hay ejemplos en Python y 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 los primeros 12 dígitos aleatoriamente
15 digits = [random.randint(0, 9) for _ in range(12)]
16
17 # Calcular el primer dígito de verificación
18 first_check = calculate_check_digit(digits)
19 digits.append(first_check)
20
21 # Calcular el segundo dígito de verificación
22 second_check = calculate_check_digit(digits)
23 digits.append(second_check)
24
25 # Formatear el 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 caracteres no numéricos
31 cnpj = ''.join(filter(str.isdigit, cnpj))
32
33 # Verificar longitud
34 if len(cnpj) != 14:
35 return False
36
37 # Verificar si todos los dígitos son iguales
38 if len(set(cnpj)) == 1:
39 return False
40
41 # Convertir a lista de enteros
42 digits = [int(d) for d in cnpj]
43
44 # Validar el primer dígito de verificación
45 first_check = calculate_check_digit(digits[:12])
46 if digits[12] != first_check:
47 return False
48
49 # Validar el segundo dígito de verificación
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 los primeros 12 dígitos aleatoriamente
10 for (int i = 0; i < 12; i++) {
11 digits[i] = random.nextInt(10);
12 }
13
14 // Calcular el primer dígito de verificación
15 digits[12] = calculateCheckDigit(digits, 12);
16
17 // Calcular el segundo dígito de verificación
18 digits[13] = calculateCheckDigit(digits, 13);
19
20 // Formatear el 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 caracteres no numéricos
45 cnpj = cnpj.replaceAll("\\D", "");
46
47 // Verificar longitud
48 if (cnpj.length() != 14) {
49 return false;
50 }
51
52 // Verificar si todos los dígitos son iguales
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 array de enteros
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ígito de verificación
71 int firstCheck = calculateCheckDigit(digits, 12);
72 if (digits[12] != firstCheck) {
73 return false;
74 }
75
76 // Validar el segundo dígito de verificación
77 int secondCheck = calculateCheckDigit(digits, 13);
78 if (digits[13] != secondCheck) {
79 return false;
80 }
81
82 return true;
83 }
84}
85Al usar esta herramienta generadora y validadora de CNPJ, ten en cuenta las siguientes consideraciones:
Un CNPJ es el número de registro nacional para empresas y entidades legales en Brasil. Se utiliza para fines fiscales, registro empresarial, apertura de cuentas bancarias e identificación de empresas en transacciones oficiales.
No. Los CNPJs generados por esta herramienta son válidos matemáticamente de acuerdo con el algoritmo de dígitos de verificación, pero no están registrados en la Receita Federal do Brasil y no pertenecen a empresas reales.
No. Para obtener un CNPJ legítimo para un negocio, debes registrarte en la Receita Federal do Brasil siguiendo el proceso oficial. Los CNPJs generados son solo para fines de prueba.
Para verificar si un CNPJ está registrado a una empresa real, debes consultar la base de datos de la Receita Federal do Brasil. Nuestra herramienta solo verifica si un CNPJ es matemáticamente válido, no si está registrado oficialmente.
Los CNPJs con todos los mismos dígitos (como 11.111.111/1111-11) se consideran automáticamente inválidos, incluso si pasan matemáticamente el algoritmo de dígitos de verificación. Esta es una regla establecida por la Receita Federal do Brasil.
No. Todo el procesamiento ocurre en tu navegador, y no almacenamos ni transmitimos ninguno de los CNPJs que generas o validas.
La versión actual de la herramienta genera un CNPJ a la vez. Para generación masiva, podrías considerar usar una de las bibliotecas de programación mencionadas en la sección de Alternativas.
Este es el formato oficial requerido por las autoridades brasileñas. La agrupación específica ayuda a identificar diferentes componentes del CNPJ, como el número base y el identificador de sucursal.
Puedes implementar el algoritmo de validación en tu lenguaje de programación preferido utilizando los ejemplos de código proporcionados en la sección de Implementación Técnica, o usar una de las bibliotecas mencionadas en la sección de Alternativas.
Sí. Las entidades gubernamentales en Brasil tienen patrones específicos de CNPJ. Por ejemplo, las entidades gubernamentales federales a menudo comienzan con dígitos específicos. Nuestro generador crea CNPJs aleatorios y no genera específicamente CNPJs de entidades gubernamentales.
Nuestra herramienta generadora y validadora de CNPJ brasileño hace que trabajar con estos números de identificación sea simple y eficiente. Ya sea que estés probando aplicaciones, preparando datos de muestra o validando CNPJs existentes, esta herramienta proporciona una solución directa sin la complejidad de integraciones de API o configuraciones avanzadas.
¡Genera tu primer CNPJ válido ahora o valida uno existente utilizando nuestra interfaz sencilla!
Descubre más herramientas que podrían ser útiles para tu flujo de trabajo