Generera giltiga brasilianska CNPJ-nummer och validera befintliga med detta enkla verktyg utformat för utvecklare och testare som arbetar med brasilianska företags-ID.
Generera ett giltigt brasilianskt CNPJ-nummer för teständamål.
Kontrollera om ett brasilianskt CNPJ-nummer är giltigt.
O CNPJ Brasileiro (Cadastro Nacional da Pessoa Jurídica) é um número de identificação único atribuído a empresas e entidades legais no Brasil. Esta ferramenta de geração e validação de CNPJ Brasileiro fornece uma maneira simples e eficiente de gerar números de CNPJ válidos para fins de teste e validar números de CNPJ existentes de acordo com o algoritmo oficial brasileiro. Seja você um desenvolvedor testando aplicativos que lidam com dados empresariais brasileiros, um profissional de QA criando casos de teste, ou qualquer pessoa trabalhando com informações de empresas brasileiras, esta ferramenta simplifica o processo de trabalho com números de CNPJ.
Diferente dos números de CNPJ reais que são oficialmente emitidos pela Receita Federal do Brasil, os CNPJs gerados por esta ferramenta são matematicamente válidos, mas não estão registrados em empresas reais. Isso os torna perfeitos para cenários de teste, dados de exemplo e ambientes de desenvolvimento onde você precisa de números de CNPJ devidamente formatados e válidos sem usar identificadores de empresas reais.
Um CNPJ (Cadastro Nacional da Pessoa Jurídica) é um número de identificação de 14 dígitos atribuído a empresas e entidades legais pela Receita Federal do Brasil. Ele serve como o equivalente brasileiro de um número de registro de empresa ou ID fiscal. Toda empresa que opera legalmente no Brasil deve ter um CNPJ, que é usado para:
O CNPJ é um identificador essencial no ecossistema empresarial brasileiro e aparece em documentos oficiais, contratos e registros financeiros.
Um CNPJ brasileiro consiste em 14 dígitos, tipicamente formatados como: XX.XXX.XXX/YYYY-ZZ
A estrutura é dividida da seguinte forma:
Por exemplo, um CNPJ devidamente formatado pode parecer: 12.345.678/0001-95
Os dígitos de verificação (os dois últimos números) são calculados usando um algoritmo matemático específico que valida a autenticidade do CNPJ. Este algoritmo garante que números gerados aleatoriamente não possam passar na validação sem seguir o método de cálculo adequado.
O algoritmo de validação do CNPJ utiliza um cálculo ponderado para determinar os dígitos de verificação. Veja como funciona:
Para que um CNPJ seja válido, ambos os dígitos de verificação devem corresponder aos valores calculados.
Nossa ferramenta de Gerador e Validador de CNPJ Brasileiro oferece duas funções principais: gerar CNPJs válidos e validar números de CNPJ existentes.
Para gerar um CNPJ válido para fins de teste:
O CNPJ gerado seguirá todas as regras de validação matemática de um CNPJ real, mas não está registrado na Receita Federal do Brasil.
Para verificar se um CNPJ é matematicamente válido:
O validador verifica se o CNPJ segue o formato correto e se os dígitos de verificação correspondem aos valores esperados de acordo com o algoritmo de validação.
Esta ferramenta de gerador e validador de CNPJ Brasileiro é particularmente útil nos seguintes cenários:
Enquanto nossa ferramenta fornece uma solução simples baseada em navegador para gerar e validar CNPJs, existem várias alternativas dependendo de suas necessidades específicas:
Para desenvolvedores que integram a validação de CNPJ diretamente em aplicativos, várias bibliotecas específicas de linguagem estão disponíveis:
cpf_cnpj.js, validator.jspython-cnpj, validate-docbrbrazilianutils, respect/validationcaelum-stella, commons-validatorcpf_cnpj, brazilian-railsEssas bibliotecas geralmente oferecem funcionalidades adicionais, como formatação, análise e validação de outros documentos brasileiros.
Para aplicativos que requerem validação sem implementar o algoritmo:
Para fins educacionais ou validações pontuais, você pode aplicar manualmente o algoritmo:
No entanto, o cálculo manual é propenso a erros e ineficiente para uso regular.
O gerador e validador de CNPJ nesta ferramenta são implementados usando JavaScript, tornando-o rápido e capaz de rodar inteiramente em seu navegador sem enviar seus dados para um servidor. Veja como as funções principais funcionam:
1function generateCNPJ() {
2 // Gere os primeiros 12 dígitos aleatoriamente
3 const digits = Array.from({ length: 12 }, () => Math.floor(Math.random() * 10));
4
5 // Calcule o primeiro dígito de verificação
6 const firstCheckDigit = calculateCheckDigit(digits);
7 digits.push(firstCheckDigit);
8
9 // Calcule o segundo dígito de verificação
10 const secondCheckDigit = calculateCheckDigit(digits);
11 digits.push(secondCheckDigit);
12
13 // Formate 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}
291function validateCNPJ(cnpj) {
2 // Remove caracteres não numéricos
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Verifique se tem o comprimento correto
6 if (cleanCNPJ.length !== 14) return false;
7
8 // Verifique padrões inválidos conhecidos (todos os mesmos dígitos)
9 if (/^(\d)\1+$/.test(cleanCNPJ)) return false;
10
11 // Converta para um array de dígitos
12 const digits = cleanCNPJ.split('').map(Number);
13
14 // Verifique o primeiro dígito de verificação
15 const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16 if (digits[12] !== expectedFirstDigit) return false;
17
18 // Verifique o 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}
241function formatCNPJ(cnpj) {
2 // Remove caracteres não numéricos
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Formate 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}
18Essas 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:
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 # Gere os primeiros 12 dígitos aleatoriamente
15 digits = [random.randint(0, 9) for _ in range(12)]
16
17 # Calcule o primeiro dígito de verificação
18 first_check = calculate_check_digit(digits)
19 digits.append(first_check)
20
21 # Calcule o segundo dígito de verificação
22 second_check = calculate_check_digit(digits)
23 digits.append(second_check)
24
25 # Formate 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 # Remove caracteres não numéricos
31 cnpj = ''.join(filter(str.isdigit, cnpj))
32
33 # Verifique o comprimento
34 if len(cnpj) != 14:
35 return False
36
37 # Verifique se todos os dígitos são os mesmos
38 if len(set(cnpj)) == 1:
39 return False
40
41 # Converta para lista de inteiros
42 digits = [int(d) for d in cnpj]
43
44 # Valide o primeiro dígito de verificação
45 first_check = calculate_check_digit(digits[:12])
46 if digits[12] != first_check:
47 return False
48
49 # Valide o segundo dígito de verificação
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 // Gere os primeiros 12 dígitos aleatoriamente
10 for (int i = 0; i < 12; i++) {
11 digits[i] = random.nextInt(10);
12 }
13
14 // Calcule o primeiro dígito de verificação
15 digits[12] = calculateCheckDigit(digits, 12);
16
17 // Calcule o segundo dígito de verificação
18 digits[13] = calculateCheckDigit(digits, 13);
19
20 // Formate 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 // Remove caracteres não numéricos
45 cnpj = cnpj.replaceAll("\\D", "");
46
47 // Verifique o comprimento
48 if (cnpj.length() != 14) {
49 return false;
50 }
51
52 // Verifique se todos os dígitos são os mesmos
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 // Converta 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 // Valide o primeiro dígito de verificação
71 int firstCheck = calculateCheckDigit(digits, 12);
72 if (digits[12] != firstCheck) {
73 return false;
74 }
75
76 // Valide o segundo dígito de verificação
77 int secondCheck = calculateCheckDigit(digits, 13);
78 if (digits[13] != secondCheck) {
79 return false;
80 }
81
82 return true;
83 }
84}
85Ao usar esta ferramenta de gerador e validador de CNPJ, mantenha as seguintes considerações em mente:
Um CNPJ é o número de registro nacional para empresas e entidades legais no Brasil. É usado para fins fiscais, registro de empresas, abertura de contas bancárias e identificação de empresas em transações oficiais.
Não. Os CNPJs gerados por esta ferramenta são válidos matematicamente de acordo com o algoritmo de dígitos de verificação, mas não estão registrados na Receita Federal do Brasil e não pertencem a empresas reais.
Não. Para obter um CNPJ legítimo para uma empresa, você deve se registrar na Receita Federal do Brasil seguindo o processo oficial. CNPJs gerados são apenas para fins de teste.
Para verificar se um CNPJ está registrado a uma empresa real, você precisa consultar o banco de dados da Receita Federal do Brasil. Nossa ferramenta apenas verifica se um CNPJ é matematicamente válido, não se está oficialmente registrado.
CNPJs com todos os mesmos dígitos (como 11.111.111/1111-11) são automaticamente considerados inválidos, mesmo que passem matematicamente no algoritmo de dígitos de verificação. Esta é uma regra estabelecida pela Receita Federal do Brasil.
Não. Todo o processamento acontece em seu navegador, e não armazenamos ou transmitimos nenhum dos CNPJs que você gera ou valida.
A versão atual da ferramenta gera um CNPJ por vez. Para geração em massa, você pode considerar usar uma das bibliotecas de programação mencionadas na seção Alternativas.
Este é o formato oficial exigido pelas autoridades brasileiras. O agrupamento específico ajuda a identificar diferentes componentes do CNPJ, como o número base e o identificador da filial.
Você pode implementar o algoritmo de validação na linguagem de programação de sua preferência usando os exemplos de código fornecidos na seção Implementação Técnica, ou usar uma das bibliotecas mencionadas na seção Alternativas.
Sim. Entidades governamentais no Brasil têm padrões específicos de CNPJ. Por exemplo, entidades do governo federal costumam começar com dígitos específicos. Nosso gerador cria CNPJs aleatórios e não gera especificamente CNPJs de entidades governamentais.
Nossa ferramenta de Gerador e Validador de CNPJ Brasileiro torna o trabalho com esses números de identificação simples e eficiente. Seja testando aplicativos, preparando dados de exemplo ou validando CNPJs existentes, esta ferramenta fornece uma solução direta sem a complexidade de integrações de API ou configurações avançadas.
Gere seu primeiro CNPJ válido agora ou valide um existente usando nossa interface simples!
Upptäck fler verktyg som kan vara användbara för din arbetsflöde