Pular para o conteúdo
🛠️
Whiz Tools

Gerador e Validador de CNPJ - Ferramenta de Identificação Empresarial Brasileira

Gere números de CNPJ válidos para testes ou valide identificadores de empresas brasileiras instantaneamente. Ferramenta gratuita com verificação de dígito de controle para desenvolvedores que trabalham com o Cadastro Nacional da Pessoa Jurídica.

Gerador e Validador de CNPJ Brasileiro

Gerador de CNPJ

Gere um número de CNPJ brasileiro válido para fins de teste.

Validador de CNPJ

Verifique se um número de CNPJ brasileiro é válido.

Calculadora de carregamento...
📚

Documentação

Entendendo Números de CNPJ Brasileiros

O CNPJ (Cadastro Nacional da Pessoa Jurídica) é a versão brasileira de um identificador de imposto corporativo — um número de 14 dígitos que identifica cada entidade empresarial legal no país. Se você está desenvolvendo software que lida com dados de empresas brasileiras, rapidamente encontrará esses números em formulários de registro, notas fiscais e integrações de API.

Aqui está o que torna esta ferramenta prática: ela gera CNPJs matematicamente válidos para testes sem usar identificadores de empresas reais. Quando você está configurando um banco de dados de teste com 1.000 registros ou depurando uma rotina de validação às 2 da manhã, você precisa de CNPJs que passem em verificações algorítmicas, mas que não correspondam acidentalmente a empresas reais. É exatamente isso que esta ferramenta gera.

Os números criados aqui seguem o algoritmo oficial de validação da Receita Federal. Eles possuem dígitos verificadores corretos e formatação adequada — simplesmente não estão registrados no banco de dados do governo. Pense neles como dados de teste sintaticamente corretos que não criarão problemas de conformidade no seu ambiente de desenvolvimento.

O que é um CNPJ e Por que Ele é Importante

Um CNPJ serve como identificador corporativo do Brasil — semelhante a um EIN nos Estados Unidos ou um Número de Registro de Empresa no Reino Unido. Toda entidade empresarial que opera legalmente no Brasil deve ter um, emitido pela Receita Federal.

Você encontrará CNPJs quando:

  • Processando pagamentos: Gateways de pagamento brasileiros exigem validação de CNPJ para contas de comerciantes
  • Conformidade fiscal: Cada nota fiscal emitida no Brasil deve incluir um CNPJ válido
  • Registro empresarial: Agências governamentais usam CNPJs para rastrear entidades legais em diferentes sistemas
  • Operações bancárias: Abertura de contas corporativas ou processamento de transferências internacionais
  • Importação/exportação: Documentação aduaneira requer verificação de CNPJ
  • Contratos governamentais: Sistemas de licitações públicas validam CNPJs antes de aceitar propostas

Na minha experiência trabalhando com plataformas de e-commerce brasileiras, um dos pontos de integração mais comuns é o fluxo de checkout onde os usuários inserem seu CNPJ para compras corporativas. Sua lógica de validação precisa capturar erros de formatação antes que o processador de pagamento o faça — caso contrário, você verá transações que falharam e que poderiam ter sido evitadas.

Estrutura e Formato do CNPJ

Um CNPJ consiste em 14 dígitos formatados como: XX.XXX.XXX/YYYY-ZZ

Detalhando a estrutura:

  1. Primeiros 8 dígitos (XX.XXX.XXX): O número base de registro exclusivamente atribuído à empresa
  2. Próximos 4 dígitos (/YYYY): Identificador de filial ou estabelecimento—/0001 indica matriz, enquanto /0002, /0003 representam locais de filiais
  3. Últimos 2 dígitos (-ZZ): Dígitos verificadores calculados através de um algoritmo ponderado

Exemplo: 12.345.678/0001-95

O que é interessante sobre o identificador de filial: quando uma empresa abre múltiplas localizações, cada uma recebe os mesmos primeiros 8 dígitos, mas um número de filial diferente. Então, se uma rede varejista tem 50 lojas, elas terão CNPJs terminando em /0001 até /0050, todos compartilhando o mesmo número base. Isso facilita identificar que múltiplos CNPJs pertencem à mesma organização.

Os dígitos de verificação não são aleatórios—são calculados usando um algoritmo de módulo-11 com sequências de pesos específicas. Essa escolha de design, comum em documentos administrativos brasileiros, torna matematicamente difícil forjar números válidos ou criar acidentalmente números válidos por meio de erros de digitação.

Como a Validação de CNPJ Realmente Funciona

O algoritmo de validação usa um cálculo de módulo-11 ponderado. Aqui está a lógica por trás dele:

Cálculo do Primeiro Dígito Verificador

  1. Pegue os primeiros 12 dígitos e multiplique cada um pelos pesos: 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
  2. Some todos os produtos
  3. Divida a soma por 11 e obtenha o resto
  4. Se o resto < 2, o dígito verificador é 0; caso contrário, é 11 - resto

Cálculo do Segundo Dígito Verificador

  1. Pegue os primeiros 13 dígitos (incluindo o primeiro dígito verificador) e multiplique pelos pesos: 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
  2. Some todos os produtos
  3. Divida por 11 e obtenha o resto
  4. Se o resto < 2, o dígito verificador é 0; caso contrário, é 11 - resto

Por que essa abordagem funciona: O sistema de multiplicação ponderada cria uma relação única entre todos os 12 dígitos base e os dígitos verificadores resultantes. Alterar até mesmo um único dígito no número base produz dígitos verificadores diferentes, o que detecta erros comuns de transcrição como trocar dois dígitos (digitar 12.345 em vez de 12.354).

Uma observação prática: CNPJs com todos os dígitos idênticos (como 11.111.111/1111-11) são automaticamente inválidos, mesmo que passem na verificação matemática. A Receita Federal exclui explicitamente esses padrões para evitar casos triviais.

Como Usar o Gerador e Validador de CNPJ

Gerando CNPJs de Teste

Precisa de um CNPJ válido para seu banco de dados de teste? Veja como:

  1. Clique em "Gerar CNPJ"
  2. A ferramenta cria um número matematicamente válido instantaneamente
  3. Clique em "Copiar" para capturá-lo na área de transferência
  4. Cole em seus formulários de teste, seeds de banco de dados ou testes unitários

Cada CNPJ gerado passa por todas as verificações de validação algorítmica, mas não está registrado na Receita Federal. Isso significa que você pode usá-los livremente no desenvolvimento sem se preocupar em usar acidentalmente o identificador de uma empresa real.

Validando Números de CNPJ

Tem um CNPJ que precisa verificar? O validador resolve:

  1. Cole ou digite o CNPJ no campo de entrada
  2. Não se preocupe com a formatação—funciona com 12345678000195 ou 12.345.678/0001-95
  3. Clique em "Validar"
  4. Receba feedback instantâneo sobre se os dígitos de verificação estão corretos

O que o validador verifica: comprimento adequado (14 dígitos), cálculos corretos dos dígitos de verificação e exclusão de padrões inválidos como dígitos iguais. O que ele não verifica: se o CNPJ está registrado no banco de dados governamental—isso requer consulta direta à Receita Federal.

Casos de Uso do Mundo Real para Gerador e Validador de CNPJ

Desenvolvimento de Software e Testes

Preenchimento de banco de dados: Ao configurar um ambiente de staging com dados de teste realistas, você precisa de dezenas ou centenas de CNPJs válidos. Criar esses manualmente é tedioso, e usar identificadores de empresas reais levanta preocupações de privacidade. CNPJs gerados resolvem ambos os problemas.

Testes de unidade com casos de borda: Sua função de validação deve rejeitar 00.000.000/0000-00 mas aceitar 11.222.333/0001-81. Ter um gerador permite criar rapidamente casos de teste válidos e intencionalmente inválidos para verificar se sua lógica lida corretamente com condições de limite.

Testes de regressão de QA: Ao testar formulários de registro ou fluxos de checkout B2B, equipes de QA precisam de novos dados de teste a cada execução. Um problema comum que já vi: ambientes de teste ficam poluídos com os mesmos 5-6 CNPJs usados repetidamente, o que mascara bugs que só aparecem com padrões específicos de dígitos.

Testes de integração de API: Se você está integrando com processadores de pagamento brasileiros como PagSeguro ou Mercado Pago, seus ambientes sandbox geralmente requerem formatação de CNPJ válida. A matemática precisa estar correta, mesmo que não esteja acessando bancos de dados de produção.

Processamento e Validação de Dados

Limpeza de dados importados: Você recebeu um CSV com 10.000 registros de empresas brasileiras. Antes de processar, precisa identificar quais CNPJs estão malformados. Executá-los pelo validador sinaliza entradas com erros de digitação, truncamento ou dígitos de verificação incorretos—economizando horas de depuração subsequente.

Validação de formulário no lado do cliente: Identificar CNPJs inválidos antes do envio do formulário melhora a experiência do usuário. Ninguém quer preencher um formulário de 20 campos para receber um erro no envio porque trocou dois dígitos do seu CNPJ.

Anonimização de dados para análise: Ao preparar dados de produção para compartilhar com equipes de análise ou parceiros externos, você precisa substituir CNPJs reais por outros válidos, mas fictícios. Isso mantém a integridade referencial do seu conjunto de dados enquanto protege identidades empresariais reais.

Operações Comerciais Internacionais

Compreendendo requisitos brasileiros: Se você está expandindo para o mercado brasileiro, encontrará requisitos de CNPJ em contratos, faturas e documentação de remessa. Ter uma ferramenta para experimentar o formato ajuda a entender o que seus sistemas precisam processar.

Especificações de integração com terceiros: Ao revisar documentação de API de provedores brasileiros de SaaS, você frequentemente verá campos de CNPJ em exemplos de payload. Poder gerar valores de teste válidos ajuda a prototipar integrações mais rapidamente.

Abordagens Alternativas de Validação de CNPJ

Bibliotecas de Programação

Se você precisa de validação de CNPJ integrada à lógica do seu aplicativo, estas bibliotecas implementam o algoritmo de dígito de verificação:

Essas bibliotecas geralmente lidam com formatação, análise e validação de múltiplos tipos de documentos brasileiros (CPF, CNPJ, etc.).

APIs de Verificação Oficial

Para sistemas de produção que precisam verificar o registro empresarial real:

  • Serviço Público da Receita Federal: A API Consulta CNPJ permite verificação no banco de dados oficial (requer autorização adequada e limitação de taxa)
  • Provedores de dados de terceiros: Serviços como Serasa Experian e Boa Vista SCPC oferecem APIs comerciais que retornam detalhes da empresa, status de registro e informações de crédito

Nota: Esses serviços verificam o registro real, não apenas a validade matemática. Você precisará de autorização adequada e deve esperar custos de API para uso em produção.

Quando Usar Cada Abordagem

Use esta ferramenta de navegador quando: Precisar de validação rápida sem instalar dependências, gerar dados de teste para demonstrações ou aprender como funciona a validação de CNPJ.

Use uma biblioteca quando: Estiver construindo um aplicativo que precisa de validação no lado do cliente ou do servidor como parte do processamento de formulário.

Use uma API oficial quando: Precisar verificar se um CNPJ corresponde a uma entidade empresarial real e ativa com status de registro atual.

Detalhes Técnicos de Implementação

Esta ferramenta é executada completamente no seu navegador usando JavaScript—sem solicitações de servidor, sem dados saindo da sua máquina. Aqui está como os algoritmos funcionam nos bastidores, com código que você pode adaptar para seus próprios projetos:

Algoritmo de Geração de CNPJ

1function generateCNPJ() {
2  // Gerar os primeiros 12 dígitos aleatoriamente
3  const digits = Array.from({ length: 12 }, () => Math.floor(Math.random() * 10));
4  
5  // Calcular o primeiro dígito verificador
6  const firstCheckDigit = calculateCheckDigit(digits);
7  digits.push(firstCheckDigit);
8  
9  // Calcular o segundo dígito verificador
10  const secondCheckDigit = calculateCheckDigit(digits);
11  digits.push(secondCheckDigit);
12  
13  // Formatar o 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 Validação de CNPJ

1function validateCNPJ(cnpj) {
2  // Remover caracteres não numéricos
3  const cleanCNPJ = cnpj.replace(/\D/g, '');
4  
5  // Verificar se tem o comprimento correto
6  if (cleanCNPJ.length !== 14) return false;
7  
8  // Verificar padrões inválidos conhecidos (todos os dígitos iguais)
9  if (/^(\d)\1+$/.test(cleanCNPJ)) return false;
10  
11  // Converter para array de dígitos
12  const digits = cleanCNPJ.split('').map(Number);
13  
14  // Verificar primeiro dígito de verificação
15  const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16  if (digits[12] !== expectedFirstDigit) return false;
17  
18  // Verificar segundo dígito de verificação
19  const expectedSecondDigit = calculateCheckDigit(digits.slice(0, 13));
20  if (digits[13] !== expectedSecondDigit) return false;
21  
22  return true;
23}
24

Função de Formatação de CNPJ

1function formatCNPJ(cnpj) {
2  // Remover caracteres não numéricos
3  const cleanCNPJ = cnpj.replace(/\D/g, '');
4  
5  // Formatar com base no comprimento
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

Essas funções principais podem ser implementadas em outras linguagens de programação seguindo a mesma lógica. Aqui estão exemplos em Python e Java:

Implementação em 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    # Gerar primeiros 12 dígitos aleatoriamente
15    digits = [random.randint(0, 9) for _ in range(12)]
16    
17    # Calcular primeiro dígito verificador
18    first_check = calculate_check_digit(digits)
19    digits.append(first_check)
20    
21    # Calcular segundo dígito verificador
22    second_check = calculate_check_digit(digits)
23    digits.append(second_check)
24    
25    # Formatar o 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    # Remover caracteres não numéricos
31    cnpj = ''.join(filter(str.isdigit, cnpj))
32    
33    # Verificar comprimento
34    if len(cnpj) != 14:
35        return False
36    
37    # Verificar se todos os dígitos são iguais
38    if len(set(cnpj)) == 1:
39        return False
40    
41    # Converter para lista de inteiros
42    digits = [int(d) for d in cnpj]
43    
44    # Validar primeiro dígito verificador
45    first_check = calculate_check_digit(digits[:12])
46    if digits[12] != first_check:
47        return False
48    
49    # Validar segundo dígito verificador
50    second_check = calculate_check_digit(digits[:13])
51    if digits[13] != second_check:
52        return False
53    
54    return True
55

Implementação em 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        // Gerar primeiros 12 dígitos aleatoriamente
10        for (int i = 0; i < 12; i++) {
11            digits[i] = random.nextInt(10);
12        }
13        
14        // Calcular primeiro dígito verificador
15        digits[12] = calculateCheckDigit(digits, 12);
16        
17        // Calcular segundo dígito verificador
18        digits[13] = calculateCheckDigit(digits, 13);
19        
20        // Formatar o 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        // Remover caracteres não numéricos
45        cnpj = cnpj.replaceAll("\\D", "");
46        
47        // Verificar comprimento
48        if (cnpj.length() != 14) {
49            return false;
50        }
51        
52        // Verificar se todos os dígitos são iguais
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        // Converter para array de inteiros
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 primeiro dígito verificador
71        int firstCheck = calculateCheckDigit(digits, 12);
72        if (digits[12] != firstCheck) {
73            return false;
74        }
75        
76        // Validar segundo dígito verificador
77        int secondCheck = calculateCheckDigit(digits, 13);
78        if (digits[13] != secondCheck) {
79            return false;
80        }
81        
82        return true;
83    }
84}
85

Limitações e Considerações Importantes

O Que Esta Ferramenta Pode e Não Pode Fazer

O que valida: Correção matemática—se os dígitos de verificação correspondem ao cálculo do algoritmo.

O que não valida: Se o CNPJ está registrado na Receita Federal, se pertence a uma empresa ativa, ou se está associado ao nome empresarial que você espera.

Pense nisso como verificação ortográfica versus verificação de fatos. Esta ferramenta informa se um CNPJ está "escrito" corretamente de acordo com as regras matemáticas, mas não pode dizer se o número corresponde a uma entidade empresarial real e ativa.

Uso Legal e Ético

CNPJs gerados são apenas para teste e desenvolvimento. São matematicamente válidos, mas não registrados nas autoridades brasileiras, o que significa:

  • ✅ Seguro para usar em: Preenchimento de bancos de dados de teste, testes unitários de lógica de validação, ambientes de QA, exemplos de código em documentação
  • ❌ Nunca usar para: Declaração de impostos, registro de empresa, assinatura de contratos, processamento de transações reais ou representação indevida de identidade empresarial

Usar um CNPJ falso para fins oficiais não é apenas antiético—é ilegal sob a lei brasileira e pode resultar em acusações de fraude.

Limitações Técnicas a Conhecer

Geração aleatória tem implicações: A ferramenta gera os primeiros 12 dígitos aleatoriamente. CNPJs reais emitidos pela Receita Federal seguem padrões internos relacionados à data de registro, escritório regional e tipo de empresa. Números gerados não corresponderão a esses padrões, o que sistemas de validação sofisticados podem sinalizar.

Sem validação semântica: Um formato de CNPJ válido não significa contexto empresarial válido. Por exemplo, entidades governamentais têm faixas específicas de CNPJ—este gerador pode criar uma coincidentemente, mas não seria significativo.

Tratamento de formato: O validador aceita vários formatos de entrada (12345678000195, 12.345.678/0001-95), mas alguns sistemas legados esperam formatação exata. Sempre teste com seus requisitos específicos de integração.

Privacidade e Segurança

Todo processamento acontece no lado do cliente, no seu navegador. Nenhum CNPJ que você gera ou valida é enviado para servidores, registrado ou armazenado. A ferramenta não solicita, processa ou manipula qualquer informação pessoal.

Perguntas Frequentes Sobre Validação de CNPJ

Qual a diferença entre validar e verificar um CNPJ?

Validação verifica se o número está matematicamente correto—formato adequado, dígitos verificadores corretos, sem padrões inválidos. Esta ferramenta faz validação.

Verificação verifica se o CNPJ está registrado com uma empresa real no banco de dados da Receita Federal. A verificação requer consulta ao banco de dados governamental e não é algo que esta ferramenta faz.

Você pode ter um CNPJ perfeitamente válido que não é verificado (como os números de teste que esta ferramenta gera), ou um CNPJ inválido que pertence a uma empresa real (porque alguém digitou errado).

Posso usar CNPJs gerados para testes de produção?

Depende do que você entende por "testes de produção". Eles são adequados para ambientes de staging, testes de carga e QA pré-lançamento. Mas se "testes de produção" significa testar com transações reais, APIs governamentais reais ou sistemas financeiros reais—então não, você precisa de CNPJs registrados reais.

Uma abordagem mais segura: use CNPJs gerados em ambientes de teste isolados, depois troque para um pequeno conjunto de CNPJs de empresas de teste reais (que você controla) ao testar integrações de produção.

Por que o validador rejeita 11.111.111/1111-11?

Mesmo que um CNPJ com dígitos idênticos possa produzir dígitos verificadores matematicamente válidos, a Receita Federal exclui explicitamente esses padrões. É uma regra de negócio, não matemática. O mesmo se aplica a padrões sequenciais em alguns sistemas de validação.

Isso é similar a como muitos sistemas rejeitam senhas como "senha123" mesmo que atendam requisitos de comprimento—são tecnicamente válidas, mas praticamente inaceitáveis.

Como lidar com validação de CNPJ em diferentes locais?

Empresas brasileiras que fazem negócios internacionais às vezes removem os caracteres de formatação ao inserir CNPJs em sistemas estrangeiros. Sua lógica de validação deve remover caracteres não numéricos antes de verificar:

1const cleanCNPJ = input.replace(/\D/g, ''); // Remove tudo exceto dígitos
2

Aceite 12.345.678/0001-95, 12345678000195 e 12 345 678 0001 95 como entradas equivalentes.

E sobre validação de CNPJ vs CPF?

CPF (Cadastro de Pessoas Físicas) é o identificador fiscal individual do Brasil, enquanto CNPJ é para empresas. Eles usam algoritmos de dígitos verificadores diferentes e comprimentos (CPF tem 11 dígitos, CNPJ tem 14). Se você está construindo um aplicativo brasileiro que lida com ambos, precisará de funções de validação separadas—embora muitas bibliotecas suportem ambos os formatos.

Um padrão comum: permitir que os usuários insiram CPF ou CNPJ no mesmo campo, depois detectar o tipo com base no comprimento após remover caracteres de formatação.

Isso funciona para empresas estrangeiras operando no Brasil?

Empresas estrangeiras que operam no Brasil também devem obter CNPJs da Receita Federal. Seus CNPJs seguem o mesmo formato e regras de validação de empresas domésticas. Não existe um formato de CNPJ especial para "empresa estrangeira".

No entanto, empresas estrangeiras podem ter requisitos de documentação adicionais e processos de registro diferentes—consulte um advogado empresarial brasileiro para detalhes específicos.

Posso consultar o banco de dados governamental para verificar o registro de CNPJ?

Sim, a Receita Federal fornece acesso público para verificar informações básicas de CNPJ através do serviço Consulta Pública CNPJ. Você pode pesquisar CNPJs manualmente ou, com autorização adequada, usar suas APIs para acesso programático.

Observe que o uso intensivo requer registro e existem limites de taxa para prevenir abuso.

Com que frequência os CNPJs mudam?

CNPJs são identificadores permanentes que não mudam quando uma empresa altera nome, endereço ou estrutura de propriedade. No entanto, se uma empresa fecha e depois se registra novamente, pode receber um novo CNPJ. Números de filial (a parte /XXXX) podem ser adicionados conforme as empresas abrem novos locais, mas o número base de 8 dígitos permanece constante.

Referências e Recursos Adicionais

Fontes Oficiais do Governo

  1. Receita Federal do Brasil - Portal Oficial - Website oficial do Serviço Federal de Receita com serviços de registro e verificação de CNPJ
  2. Consulta Pública CNPJ - Consulta Pública de CNPJ - Serviço oficial do governo para verificar o status de registro do CNPJ
  3. Instrução Normativa RFB Nº 1863/2018 - Regulamentações legais que regem o registro e uso do CNPJ no Brasil

Padrões Técnicos e Documentação

  1. Algoritmos de aritmética modular - O cálculo do dígito verificador usa aritmética modulo 11, uma abordagem padrão para dígitos de validação
  2. ISO/IEC 7064 - Padrão internacional para sistemas de dígitos verificadores que influenciou o design de validação de documentos brasileiros
  3. Código Civil Brasileiro (Lei Nº 10.406/2002) - Estrutura legal que define classificações de entidades empresariais que requerem registro de CNPJ

Recursos para Desenvolvedores

  1. Registro de pacotes NPM - npmjs.com - Repositório de bibliotecas JavaScript, incluindo validadores de documentos brasileiros
  2. PyPI (Índice de Pacotes Python) - pypi.org - Bibliotecas Python para validação de CNPJ e processamento de documentos brasileiros
  3. GitHub - Implementações de código aberto para validação de CNPJ em múltiplas linguagens de programação

Comece a Gerar e Validar CNPJs

Seja você que está construindo uma plataforma de e-commerce brasileira, testando integrações de pagamento com Mercado Pago ou apenas precisando entender como funciona a validação de CNPJ, esta ferramenta oferece acesso imediato a recursos de geração e validação.

Sem instalação, sem chaves de API, sem configurações complicadas. Basta abrir seu navegador e começar a trabalhar com identificadores de empresas brasileiras válidos.