Saltar al contenido
🛠️
Whiz Tools

Generador y Validador de CNPJ - Herramienta de Identificación Empresarial Brasileña

Genere números de CNPJ válidos para pruebas o valide identificadores empresariales brasileños al instante. Herramienta gratuita con verificación de dígito de control para desarrolladores que trabajan con el Cadastro Nacional da Pessoa Jurídica.

Generador y Validador de CNPJ Brasileño

Generador de CNPJ

Generar un número de CNPJ brasileño válido para propósitos de prueba.

Validador de CNPJ

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

Calculadora de carga...
📚

Documentación

Comprendiendo los Números de CNPJ Brasileños

El CNPJ (Cadastro Nacional da Pessoa Jurídica) es la versión brasileña de un identificador fiscal corporativo, un número de 14 dígitos que identifica cada entidad empresarial legal en el país. Si estás desarrollando software que maneja datos comerciales brasileños, rápidamente te encontrarás con estos números en formularios de registro, facturas e integraciones de API.

Aquí está lo que hace que esta herramienta sea práctica: genera CNPJs matemáticamente válidos para pruebas sin usar identificadores de empresas reales. Cuando estás configurando una base de datos de prueba con 1,000 registros o depurando una rutina de validación a las 2 AM, necesitas CNPJs que pasen verificaciones algorítmicas pero que no coincidan accidentalmente con empresas reales. Eso es exactamente lo que genera.

Los números creados aquí siguen el algoritmo de validación oficial de la Receita Federal (Servicio de Ingresos Federales de Brasil). Tienen dígitos de verificación correctos y un formato adecuado, simplemente no están registrados en la base de datos gubernamental. Piensa en ellos como datos de prueba sintácticamente correctos que no crearán problemas de cumplimiento en tu entorno de desarrollo.

Qué es un CNPJ y por qué es importante

Un CNPJ sirve como identificador corporativo de Brasil, similar a un EIN en los Estados Unidos o un Número de Registro de Empresa en el Reino Unido. Cada entidad comercial que opera legalmente en Brasil debe tener uno, emitido por la Receita Federal (Servicio de Ingresos Federales).

Encontrarás CNPJs cuando:

  • Procesamiento de pagos: Las pasarelas de pago brasileñas requieren validación de CNPJ para cuentas de comerciantes
  • Cumplimiento fiscal: Cada factura emitida en Brasil debe incluir un CNPJ válido
  • Registro empresarial: Las agencias gubernamentales utilizan CNPJs para rastrear entidades legales en diferentes sistemas
  • Operaciones bancarias: Apertura de cuentas corporativas o procesamiento de transferencias internacionales
  • Importación/exportación: La documentación aduanera requiere verificación de CNPJ
  • Contratos gubernamentales: Los sistemas de licitación pública validan CNPJs antes de aceptar ofertas

En mi experiencia trabajando con plataformas de comercio electrónico brasileñas, uno de los puntos de integración más comunes es el flujo de pago donde los usuarios ingresan su CNPJ para compras corporativas. La lógica de validación debe detectar errores de formato antes de que lo haga el procesador de pagos; de lo contrario, verás transacciones fallidas que podrían haberse evitado.

Estructura y Formato de CNPJ

Un CNPJ consta de 14 dígitos con el formato: XX.XXX.XXX/YYYY-ZZ

Desglosando la estructura:

  1. Primeros 8 dígitos (XX.XXX.XXX): El número de registro base asignado de manera única a la empresa
  2. Siguientes 4 dígitos (/YYYY): Identificador de sucursal o establecimiento—/0001 indica la sede, mientras que /0002, /0003 representan ubicaciones de sucursales
  3. Últimos 2 dígitos (-ZZ): Dígitos de verificación calculados mediante un algoritmo ponderado

Ejemplo: 12.345.678/0001-95

Lo interesante del identificador de sucursal: cuando una empresa abre múltiples ubicaciones, cada una recibe los mismos primeros 8 dígitos pero un número de sucursal diferente. Así, si una cadena minorista tiene 50 tiendas, tendrán CNPJs que terminan en /0001 hasta /0050, todos compartiendo el mismo número base. Esto facilita identificar que múltiples CNPJs pertenecen a la misma organización matriz.

Los dígitos de verificación no son aleatorios—se calculan utilizando un algoritmo de módulo-11 con secuencias de pesos específicas. Esta elección de diseño, común en documentos administrativos brasileños, hace matemáticamente difícil falsificar números válidos o crear accidentalmente números válidos mediante errores tipográficos.

Cómo Funciona Realmente la Validación de CNPJ

El algoritmo de validación utiliza un cálculo de módulo-11 ponderado. Aquí está la lógica detrás de este proceso:

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

  1. Tomar los primeros 12 dígitos y multiplicar cada uno por los pesos: 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
  2. Sumar todos los productos
  3. Dividir la suma por 11 y obtener el resto
  4. Si el resto < 2, el dígito de verificación es 0; de lo contrario es 11 - resto

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

  1. Tomar los primeros 13 dígitos (incluyendo el primer dígito de verificación) y multiplicar por los pesos: 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
  2. Sumar todos los productos
  3. Dividir por 11 y obtener el resto
  4. Si el resto < 2, el dígito de verificación es 0; de lo contrario es 11 - resto

Por qué este enfoque funciona: El sistema de multiplicación ponderada crea una relación única entre todos los 12 dígitos base y los dígitos de verificación resultantes. Cambiar incluso un solo dígito en el número base produce diferentes dígitos de verificación, lo que detecta errores comunes de transcripción como intercambiar dos dígitos (escribir 12.345 en lugar de 12.354).

Una nota práctica: Los CNPJs con todos los dígitos idénticos (como 11.111.111/1111-11) son automáticamente inválidos, incluso si pasan la verificación matemática. La Receita Federal excluye explícitamente estos patrones para prevenir casos triviales.

Cómo Usar el Generador y Validador de CNPJ

Generando CNPJs de Prueba

¿Necesitas un CNPJ válido para tu base de datos de pruebas? Así es como:

  1. Haz clic en "Generar CNPJ"
  2. La herramienta crea un número matemáticamente válido al instante
  3. Haz clic en "Copiar" para copiarlo al portapapeles
  4. Pégalo en tus formularios de prueba, semillas de base de datos o pruebas unitarias

Cada CNPJ generado pasa todas las verificaciones de validación algorítmica pero no está registrado en la Receita Federal. Esto significa que puedes usarlos libremente en desarrollo sin preocuparte de usar accidentalmente el identificador de una empresa real.

Validando Números de CNPJ

¿Tienes un CNPJ que necesitas verificar? El validador lo maneja:

  1. Pega o escribe el CNPJ en el campo de entrada
  2. No te preocupes por el formato—funciona con 12345678000195 o 12.345.678/0001-95
  3. Haz clic en "Validar"
  4. Obtén retroalimentación instantánea sobre si los dígitos de verificación son correctos

Lo que el validador comprueba: longitud adecuada (14 dígitos), cálculos correctos de dígitos de verificación y exclusión de patrones inválidos como dígitos iguales. Lo que no comprueba: si el CNPJ está registrado en la base de datos gubernamental—eso requiere consultar directamente a la Receita Federal.

Casos de Uso del Mundo Real para Generador y Validador de CNPJ

Desarrollo de Software y Pruebas

Sembrado de bases de datos: Al configurar un entorno de pruebas con datos de prueba realistas, necesitas docenas o cientos de CNPJs válidos. Crearlos manualmente es tedioso, y usar identificadores de empresas reales plantea problemas de privacidad. Los CNPJs generados resuelven ambos problemas.

Pruebas de casos límite de unidad: Tu función de validación debe rechazar 00.000.000/0000-00 pero aceptar 11.222.333/0001-81. Tener un generador te permite crear rápidamente casos de prueba válidos e intencionalmente inválidos para verificar que tu lógica maneje correctamente las condiciones límite.

Pruebas de regresión de QA: Al probar formularios de registro o flujos de pago B2B, los equipos de QA necesitan datos de prueba frescos para cada ejecución. Un problema común que he visto: los entornos de prueba se contaminan con los mismos 5-6 CNPJs usados repetidamente, lo que oculta errores que solo aparecen con patrones de dígitos específicos.

Pruebas de integración de API: Si estás integrando procesadores de pago brasileños como PagSeguro o Mercado Pago, sus entornos de pruebas a menudo requieren un formato de CNPJ válido. Las matemáticas deben ser correctas incluso cuando no estás accediendo a bases de datos de producción.

Procesamiento y Validación de Datos

Limpieza de datos importados: Has recibido un CSV con 10,000 registros de empresas brasileñas. Antes de procesar, necesitas identificar qué CNPJs están mal formados. Ejecutarlos a través del validador marca las entradas con errores tipográficos, truncamiento o dígitos de verificación incorrectos, ahorrando horas de depuración posterior.

Validación de formularios del lado del cliente: Detectar CNPJs inválidos antes del envío del formulario mejora la experiencia del usuario. Nadie quiere llenar un formulario de registro de 20 campos solo para obtener un error al enviarlo porque intercambió dos dígitos en su CNPJ.

Anonimización de datos para análisis: Al preparar datos de producción para compartir con equipos de análisis o socios externos, necesitas reemplazar CNPJs reales con otros válidos pero ficticios. Esto mantiene la integridad referencial en tu conjunto de datos mientras protege las identidades comerciales reales.

Operaciones Comerciales Internacionales

Comprender los requisitos brasileños: Si estás expandiéndote al mercado brasileño, encontrarás requisitos de CNPJ en contratos, facturas y documentación de envío. Tener una herramienta para experimentar con el formato te ayuda a entender qué necesitan tus sistemas para manejarlos.

Especificaciones de integración de terceros: Al revisar la documentación de API de proveedores brasileños de SaaS, a menudo verás campos de CNPJ en ejemplos de carga útil. Poder generar valores de prueba válidos te ayuda a prototipar integraciones más rápidamente.

Enfoques Alternativos de Validación de CNPJ

Bibliotecas de Programación

Si necesita validación de CNPJ integrada en la lógica de su aplicación, estas bibliotecas implementan el algoritmo de dígito de verificación:

Estas bibliotecas generalmente manejan el formateo, análisis y validación de múltiples tipos de documentos brasileños (CPF, CNPJ, etc.).

API de Verificación Oficial

Para sistemas de producción que necesitan verificar el registro comercial real:

  • Servicio Público de Receita Federal: La API de Consulta CNPJ permite la verificación contra la base de datos oficial (requiere autorización adecuada y límite de tasa)
  • Proveedores de datos de terceros: Servicios como Serasa Experian y Boa Vista SCPC ofrecen API comerciales que devuelven detalles de empresas, estado de registro e información de crédito

Nota: Estos servicios verifican el registro real, no solo la validez matemática. Necesitará autorización adecuada y debe esperar costos de API para uso en producción.

Cuándo Usar Cada Enfoque

Use esta herramienta de navegador cuando: Necesite una validación rápida sin instalar dependencias, generar datos de prueba para demostraciones o aprender cómo funciona la validación de CNPJ.

Use una biblioteca cuando: Esté construyendo una aplicación que necesite validación del lado del cliente o del servidor como parte del procesamiento de formularios.

Use una API oficial cuando: Necesite verificar que un CNPJ corresponda a una entidad comercial real y activa con estado de registro actual.

Detalles Técnicos de Implementación

Esta herramienta se ejecuta completamente en su navegador utilizando JavaScript, sin solicitudes al servidor y sin que los datos salgan de su máquina. Así es como funcionan los algoritmos internamente, con código que puede adaptar para sus propios proyectos:

Algoritmo de Generación de CNPJ

1function generateCNPJ() {
2  // Generar los primeros 12 dígitos de forma aleatoria
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 dígitos iguales)
9  if (/^(\d)\1+$/.test(cleanCNPJ)) return false;
10  
11  // Convertir a array de dígitos
12  const digits = cleanCNPJ.split('').map(Number);
13  
14  // Verificar primer dígito de verificación
15  const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16  if (digits[12] !== expectedFirstDigit) return false;
17  
18  // Verificar 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 primeros 12 dígitos de forma aleatoria
15    digits = [random.randint(0, 9) for _ in range(12)]
16    
17    # Calcular primer dígito de verificación
18    first_check = calculate_check_digit(digits)
19    digits.append(first_check)
20    
21    # Calcular 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 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 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 primeros 12 dígitos de forma aleatoria
10        for (int i = 0; i < 12; i++) {
11            digits[i] = random.nextInt(10);
12        }
13        
14        // Calcular primer dígito de verificación
15        digits[12] = calculateCheckDigit(digits, 12);
16        
17        // Calcular 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 primer dígito de verificación
71        int firstCheck = calculateCheckDigit(digits, 12);
72        if (digits[12] != firstCheck) {
73            return false;
74        }
75        
76        // Validar 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

Limitaciones y Consideraciones Importantes

Lo Que Esta Herramienta Puede y No Puede Hacer

Lo que valida: Corrección matemática: si los dígitos de verificación coinciden con el cálculo del algoritmo.

Lo que no valida: Si el CNPJ está registrado en la Receita Federal, si pertenece a una empresa activa o si está asociado con el nombre comercial que espera.

Piénselo como la diferencia entre corrección ortográfica y verificación de hechos. Esta herramienta le indica si un CNPJ está "escrito" correctamente según las reglas matemáticas, pero no puede decirle si el número corresponde a una entidad comercial real y activa.

Uso Legal y Ético

Los CNPJ generados son solo para pruebas y desarrollo. Son matemáticamente válidos pero no están registrados ante las autoridades brasileñas, lo que significa:

  • ✅ Seguro para usar en: Poblar bases de datos de prueba, pruebas unitarias de lógica de validación, entornos de control de calidad, ejemplos de código en documentación
  • ❌ Nunca usar para: Declaraciones fiscales, registro de empresas, firma de contratos, procesamiento de transacciones reales o representación falsa de identidad empresarial

Usar un CNPJ falso para fines oficiales no solo es poco ético, sino ilegal según la legislación brasileña y puede resultar en cargos por fraude.

Limitaciones Técnicas a Conocer

La generación aleatoria tiene implicaciones: La herramienta genera los primeros 12 dígitos de forma aleatoria. Los CNPJ reales emitidos por la Receita Federal siguen patrones internos relacionados con la fecha de registro, oficina regional y tipo de negocio. Los números generados no coincidirán con estos patrones, lo que los sistemas de validación sofisticados podrían marcar.

Sin validación semántica: Un formato de CNPJ válido no significa un contexto comercial válido. Por ejemplo, las entidades gubernamentales tienen rangos de CNPJ específicos: este generador podría crear uno por coincidencia, pero no sería significativo.

Manejo de formato: El validador acepta varios formatos de entrada (12345678000195, 12.345.678/0001-95), pero algunos sistemas heredados esperan un formato exacto. Siempre pruebe con sus requisitos de integración específicos.

Privacidad y Seguridad

Todo el procesamiento se realiza del lado del cliente en su navegador. Ningún CNPJ que genere o valide se envía a servidores, se registra o se almacena. La herramienta no solicita, maneja ni procesa ninguna información personal.

Preguntas Frecuentes Sobre la Validación de CNPJ

¿Cuál es la diferencia entre validar y verificar un CNPJ?

Validación verifica si el número es matemáticamente correcto: formato adecuado, dígitos de control correctos, sin patrones inválidos. Esta herramienta realiza la validación.

Verificación comprueba si el CNPJ está registrado con una empresa real en la base de datos de la Receita Federal. La verificación requiere consultar la base de datos gubernamental y no es algo que esta herramienta haga.

Puedes tener un CNPJ perfectamente válido que no esté verificado (como los números de prueba que esta herramienta genera), o un CNPJ inválido que pertenezca a una empresa real (porque alguien cometió un error al ingresarlo).

¿Puedo usar CNPJs generados para pruebas de producción?

Depende de lo que entiendas por "pruebas de producción". Son adecuados para entornos de preparación, pruebas de carga y control de calidad previo al lanzamiento. Pero si "pruebas de producción" significa probar con transacciones reales, API gubernamentales reales o sistemas financieros reales, entonces no, necesitas CNPJs registrados reales.

Un enfoque más seguro: usa CNPJs generados en entornos de prueba aislados, luego cambia a un pequeño conjunto de CNPJs de empresas de prueba reales (que controles) al probar integraciones de producción.

¿Por qué el validador rechaza 11.111.111/1111-11?

Aunque un CNPJ con dígitos idénticos puede producir matemáticamente dígitos de control válidos, la Receita Federal excluye explícitamente estos patrones. Es una regla de negocio, no matemática. Lo mismo se aplica a patrones secuenciales en algunos sistemas de validación.

Esto es similar a cómo muchos sistemas rechazan contraseñas como "password123" aunque cumplan con los requisitos de longitud: son técnicamente válidas pero prácticamente inaceptables.

¿Cómo manejo la validación de CNPJ en diferentes localizaciones?

Las empresas brasileñas que hacen negocios internacionales a veces eliminan los caracteres de formato al ingresar CNPJs en sistemas extranjeros. Tu lógica de validación debe eliminar los caracteres no numéricos antes de verificar:

1const cleanCNPJ = input.replace(/\D/g, ''); // Eliminar todo excepto dígitos
2

Acepta 12.345.678/0001-95, 12345678000195 y 12 345 678 0001 95 como entradas equivalentes.

¿Qué hay de la validación de CNPJ vs CPF?

CPF (Cadastro de Pessoas Físicas) es el ID fiscal individual de Brasil, mientras que CNPJ es para empresas. Utilizan diferentes algoritmos de dígitos de control y longitudes (CPF tiene 11 dígitos, CNPJ tiene 14). Si estás creando una aplicación brasileña que maneja ambos, necesitarás funciones de validación separadas, aunque muchas bibliotecas admiten ambos formatos.

Un patrón común: permitir a los usuarios ingresar CPF o CNPJ en el mismo campo, luego detectar qué tipo se basa en la longitud después de eliminar los caracteres de formato.

¿Funciona para empresas extranjeras que operan en Brasil?

Las empresas extranjeras que operan en Brasil también deben obtener CNPJs de la Receita Federal. Sus CNPJs siguen el mismo formato y reglas de validación que las empresas nacionales. No existe un formato de CNPJ especial para "empresas extranjeras".

Sin embargo, las empresas extranjeras pueden tener requisitos de documentación adicionales y procesos de registro diferentes: consulte con un abogado de negocios brasileño para obtener detalles específicos.

¿Puedo consultar la base de datos gubernamental para verificar el registro de CNPJ?

Sí, la Receita Federal proporciona acceso público para verificar información básica de CNPJ a través de su servicio de Consulta Pública CNPJ. Puedes buscar CNPJs manualmente o, con la autorización adecuada, usar sus API para acceso programático.

Tenga en cuenta que el uso intensivo requiere registro y hay límites de velocidad para prevenir abusos.

¿Con qué frecuencia cambian los CNPJs?

Los CNPJs son identificadores permanentes que no cambian cuando una empresa modifica su nombre, dirección o estructura de propiedad. Sin embargo, si una empresa cierra y luego se vuelve a registrar, puede recibir un nuevo CNPJ. Los números de sucursal (la parte /XXXX) pueden agregarse cuando las empresas abren nuevas ubicaciones, pero el número base de 8 dígitos permanece constante.

Referencias y Recursos Adicionales

Fuentes Oficiales del Gobierno

  1. Receita Federal do Brasil - Portal Oficial - El sitio web oficial del Servicio de Ingresos Federales de Brasil con servicios de registro y verificación de CNPJ
  2. Consulta Pública CNPJ - Búsqueda Pública de CNPJ - Servicio oficial del gobierno para verificar el estado de registro de CNPJ
  3. Instrucción Normativa RFB No. 1863/2018 - Regulaciones legales que rigen el registro y uso de CNPJ en Brasil

Estándares Técnicos y Documentación

  1. Algoritmos de aritmética modular - El cálculo del dígito de verificación utiliza aritmética modulo 11, un enfoque estándar para dígitos de validación
  2. ISO/IEC 7064 - Estándar internacional para sistemas de dígitos de verificación que influyó en el diseño de validación de documentos brasileños
  3. Código Civil Brasileño (Ley No. 10.406/2002) - Marco legal que define las clasificaciones de entidades comerciales que requieren registro de CNPJ

Recursos para Desarrolladores

  1. Registro de paquetes NPM - npmjs.com - Repositorio de bibliotecas de JavaScript, incluidos validadores de documentos brasileños
  2. PyPI (Índice de Paquetes de Python) - pypi.org - Bibliotecas de Python para validación de CNPJ y procesamiento de documentos brasileños
  3. GitHub - Implementaciones de código abierto de validación de CNPJ en múltiples lenguajes de programación

Comenzar a Generar y Validar CNPJs

Ya sea que esté construyendo una plataforma de comercio electrónico brasileña, probando integraciones de pago con Mercado Pago, o simplemente necesita comprender cómo funciona la validación de CNPJ, esta herramienta le brinda acceso inmediato a capacidades de generación y validación.

Sin instalación, sin claves API, sin configuraciones complicadas. Simplemente abra su navegador y comience a trabajar con identificadores empresariales brasileños válidos.