🛠️

Whiz Tools

Build • Create • Innovate

Generador y validador de CNPJ brasileño para pruebas

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.

Generador y Validador de CNPJ Brasileño

Generador de CNPJ

Genera un número de CNPJ brasileño válido para fines de prueba.

Validador de CNPJ

Verifica si un número de CNPJ brasileño es válido.

📚

Documentación

Generador y Validador de CNPJ Brasileño

Introducción

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.

¿Qué es un CNPJ?

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:

  • Reporte y cumplimiento fiscal
  • Registro de empresas ante agencias gubernamentales
  • Apertura de cuentas bancarias
  • Emisión de facturas y recibos
  • Participación en licitaciones gubernamentales
  • Importación y exportación de bienes

El CNPJ es un identificador esencial en el ecosistema empresarial de Brasil y aparece en documentos oficiales, contratos y registros financieros.

Estructura y Formato del CNPJ

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:

  1. Primeros 8 dígitos (XX.XXX.XXX): Número base asignado a la empresa
  2. 4 dígitos después de la barra (YYYY): Identificador de sucursal (0001 para la sede, otros números para sucursales)
  3. Últimos 2 dígitos (ZZ): Dígitos de verificación para validación

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.

Cómo Funciona la Validación del CNPJ

El algoritmo de validación del CNPJ utiliza un cálculo ponderado para determinar los dígitos de verificación. Así es como funciona:

Cálculo del Primer Dígito de Verificación

  1. Multiplica cada uno de los primeros 12 dígitos por una secuencia de pesos: 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
  2. Suma los resultados de estas multiplicaciones
  3. Calcula el resto de esta suma dividido por 11
  4. Si el resto es menor que 2, el primer dígito de verificación es 0; de lo contrario, es 11 menos el resto

Cálculo del Segundo Dígito de Verificación

  1. Multiplica cada uno de los primeros 13 dígitos (incluido el primer dígito de verificación) por una secuencia de pesos: 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
  2. Suma los resultados de estas multiplicaciones
  3. Calcula el resto de esta suma dividido por 11
  4. Si el resto es menor que 2, el segundo dígito de verificación es 0; de lo contrario, es 11 menos el resto

Para que un CNPJ sea válido, ambos dígitos de verificación deben coincidir con los valores calculados.

Cómo Usar Esta Herramienta

Nuestra herramienta generadora y validadora de CNPJ brasileño ofrece dos funciones principales: generar CNPJs válidos y validar números de CNPJ existentes.

Generando un CNPJ

Para generar un CNPJ válido para fines de prueba:

  1. Navega a la sección "Generador de CNPJ" de la herramienta
  2. Haz clic en el botón "Generar CNPJ"
  3. Aparecerá un CNPJ matemáticamente válido en la pantalla formateada
  4. Usa el botón "Copiar" para copiar el CNPJ generado en tu portapapeles

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.

Validando un CNPJ

Para verificar si un CNPJ es matemáticamente válido:

  1. Navega a la sección "Validador de CNPJ" de la herramienta
  2. Ingresa el CNPJ que deseas validar en el campo de entrada
    • La herramienta acepta CNPJs con o sin formato (puntos, barras y guiones)
  3. Haz clic en el botón "Validar"
  4. La herramienta mostrará si el CNPJ es válido o inválido según el algoritmo de dígitos de verificación

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.

Casos de Uso

Esta herramienta generadora y validadora de CNPJ brasileño es particularmente útil en los siguientes escenarios:

Desarrollo de Software y Pruebas

  • Creación de Datos de Prueba: Generar CNPJs válidos para poblar bases de datos de prueba sin usar identificadores de empresas reales
  • Pruebas Unitarias: Validar funciones de manejo de CNPJ en tu código con ejemplos válidos e inválidos conocidos
  • Pruebas de QA: Crear casos de prueba para formularios e interfaces que requieren entrada de CNPJ
  • Pruebas de Integración: Probar sistemas que intercambian datos con servicios gubernamentales brasileños o instituciones financieras

Educación y Capacitación

  • Aprender el Formato del CNPJ: Comprender cómo están estructurados los identificadores empresariales brasileños
  • Estudio de Algoritmos: Examinar cómo funciona la validación de dígitos de verificación en la práctica
  • Técnicas de Validación de Datos: Estudiar ejemplos del mundo real de requisitos de validación de datos

Procesamiento de Datos

  • Limpieza de Datos: Validar CNPJs en conjuntos de datos existentes para identificar posibles errores
  • Validación de Formularios: Implementar validación del lado del cliente o del servidor para entradas de CNPJ
  • Anonimización de Datos: Reemplazar CNPJs reales por válidos generados cuando se preparan conjuntos de datos para análisis

Negocios Internacionales

  • Preparación para Ingreso al Mercado: Comprender los requisitos de identificación empresarial en Brasil
  • Preparación de Documentos: Asegurarse de que el formato sea correcto al preparar documentos empresariales para Brasil
  • Verificación de Cumplimiento: Verificar que los números de CNPJ recopilados sean al menos matemáticamente válidos

Alternativas

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:

Bibliotecas de Programación

Para desarrolladores que integran la validación de CNPJ directamente en aplicaciones, hay varias bibliotecas específicas de lenguaje disponibles:

  • JavaScript: cpf_cnpj.js, validator.js
  • Python: python-cnpj, validate-docbr
  • PHP: brazilianutils, respect/validation
  • Java: caelum-stella, commons-validator
  • Ruby: cpf_cnpj, brazilian-rails

Estas bibliotecas a menudo proporcionan funcionalidad adicional como formateo, análisis y validación de otros documentos brasileños.

Servicios API

Para aplicaciones que requieren validación sin implementar el algoritmo:

  • APIs del gobierno brasileño (requiere registro)
  • APIs de validación comerciales que incluyen verificación de CNPJ
  • Servicios de información empresarial que validan contra la base de datos oficial

Cálculo Manual

Para fines educativos o validaciones únicas, puedes aplicar manualmente el algoritmo:

  1. Extrae los primeros 12 dígitos del CNPJ
  2. Realiza los cálculos ponderados como se describió anteriormente
  3. Compara los dígitos de verificación calculados con los dígitos de verificación reales

Sin embargo, el cálculo manual es propenso a errores e ineficiente para el uso regular.

Implementación Técnica

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:

Algoritmo de Generación de CNPJ

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}
29

Algoritmo de Validación de CNPJ

1function 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}
24

Función de Formateo de CNPJ

1function 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}
18

Estas funciones principales pueden implementarse en otros lenguajes de programación siguiendo la misma lógica. Aquí hay ejemplos en Python y Java:

Implementación en 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    # 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
55

Implementación en 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        // 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}
85

Consideraciones Importantes

Al usar esta herramienta generadora y validadora de CNPJ, ten en cuenta las siguientes consideraciones:

Consideraciones Legales y Éticas

  • No para Fraude: Los CNPJs generados nunca deben ser utilizados para fines fraudulentos o de tergiversación
  • Solo para Pruebas: Estos CNPJs son solo para fines de prueba y desarrollo
  • No Registrados: Los CNPJs generados son válidos matemáticamente pero no están registrados ante las autoridades brasileñas
  • Sin Validez en el Mundo Real: No pueden ser utilizados para registro empresarial o fines fiscales reales

Limitaciones Técnicas

  • Sin Información Empresarial: Los CNPJs generados no contienen códigos de sector empresarial reales o información de ubicación
  • Sin Verificación de Base de Datos: El validador solo verifica la validez matemática, no el estado de registro
  • Variaciones de Formato: Si bien la herramienta maneja variaciones de formato comunes, algunos sistemas pueden requerir formatos específicos

Consideraciones de Seguridad

  • Procesamiento del Lado del Cliente: Todo el procesamiento ocurre en tu navegador; no se envían datos a servidores
  • Sin Almacenamiento de Datos: Los CNPJs generados no se almacenan ni se registran
  • Sin Datos Personales: La herramienta no maneja ni procesa información personal

Preguntas Frecuentes

¿Para qué se utiliza un CNPJ en Brasil?

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.

¿Son reales los CNPJs generados por esta herramienta?

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.

¿Puedo usar CNPJs generados para mi negocio?

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.

¿Cómo puedo saber si un CNPJ pertenece a una empresa real?

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.

¿Por qué el validador rechaza un CNPJ con todos los mismos dígitos?

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.

¿La herramienta almacena los CNPJs que genero o valido?

No. Todo el procesamiento ocurre en tu navegador, y no almacenamos ni transmitimos ninguno de los CNPJs que generas o validas.

¿Puedo generar múltiples CNPJs a la vez?

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.

¿Por qué es importante el formato XX.XXX.XXX/XXXX-XX?

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.

¿Cómo valido un CNPJ programáticamente?

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.

¿Existen CNPJs especiales para entidades gubernamentales?

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.

Referencias

  1. Receita Federal do Brasil - Sitio Oficial
  2. "CNPJ - Cadastro Nacional da Pessoa Jurídica" - Wikipedia
  3. Código Civil Brasileño (Ley No. 10.406/2002) - Marco legal para entidades empresariales en Brasil
  4. Instrucción Normativa de Registro Empresarial de Brasil (IN RFB No. 1863/2018) - Regulaciones sobre el registro de CNPJ

Pruébalo Ahora

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!

🔗

Herramientas Relacionadas

Descubre más herramientas que podrían ser útiles para tu flujo de trabajo

Generador y Validador de CBU Argentino | Códigos Bancarios

Prueba esta herramienta

Generador y validador de IBAN para pruebas y verificación

Prueba esta herramienta

Generador de CPF Válido para Pruebas y Desarrollo de Software

Prueba esta herramienta

Generador y Validador de CUIT/CUIL Argentino

Prueba esta herramienta

Generador y Validador de CUIT de Argentina para Fines de Prueba

Prueba esta herramienta

Probador y Validador de Patrones Regex: Prueba, Resalta y Guarda Patrones

Prueba esta herramienta

Generador y Validador de Números de Teléfono para Múltiples Países

Prueba esta herramienta

Generador de RFC Mexicano para Pruebas | Crea Códigos de Identificación Fiscal Válidos

Prueba esta herramienta

Generador y Validador de CLABE Mexicana para Pruebas de Software

Prueba esta herramienta