Como Validar CNPJ: Algoritmo Completo com Exemplos de Código

O CNPJ (Cadastro Nacional da Pessoa Jurídica) é o documento que identifica empresas no Brasil. Se você desenvolve sistemas fiscais, ERPs, e-commerces ou qualquer plataforma que cadastra empresas, saber validar um CNPJ corretamente é obrigatório.

Neste guia, vamos dissecar o algoritmo oficial da Receita Federal, implementá-lo em 3 linguagens e cobrir os erros mais comuns que levam a bugs em produção.

Estrutura do CNPJ

O CNPJ possui 14 dígitos no formato XX.XXX.XXX/YYYY-DD:

O Algoritmo de Validação (Módulo 11)

Assim como o CPF, o CNPJ usa o método de módulo 11, mas com pesos diferentes e em duas etapas:

Passo 1: Calcular o primeiro dígito verificador

1. Multiplique os 12 primeiros dígitos pelos pesos: 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
2. Some todos os resultados
3. Calcule o resto da divisão por 11
4. Se o resto for menor que 2, o dígito é 0. Senão, é 11 - resto

Passo 2: Calcular o segundo dígito verificador

1. Multiplique os 13 primeiros dígitos (incluindo o 1º verificador) pelos pesos: 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
2. Repita o cálculo de módulo 11

Exemplo prático

Para o CNPJ 11.222.333/0001-81:

Dígitos: 1 1 2 2 2 3 3 3 0 0 0 1
Pesos:   5 4 3 2 9 8 7 6 5 4 3 2

1×5 + 1×4 + 2×3 + 2×2 + 2×9 + 3×8 + 3×7 + 3×6 + 0×5 + 0×4 + 0×3 + 1×2
= 5 + 4 + 6 + 4 + 18 + 24 + 21 + 18 + 0 + 0 + 0 + 2 = 102

102 % 11 = 3 → 11 - 3 = 8 ✅ (primeiro dígito)

Implementação em JavaScript

function validarCNPJ(cnpj) {
  // Remove caracteres não numéricos
  cnpj = cnpj.replace(/\D/g, '');

  // Verifica se tem 14 dígitos
  if (cnpj.length !== 14) return false;

  // Rejeita CNPJs com todos os dígitos iguais
  if (/^(\d)\1{13}$/.test(cnpj)) return false;

  // Pesos para o cálculo
  const peso1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
  const peso2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];

  // Primeiro dígito verificador
  let soma = 0;
  for (let i = 0; i < 12; i++) {
    soma += parseInt(cnpj.charAt(i)) * peso1[i];
  }
  let resto = soma % 11;
  const dig1 = resto < 2 ? 0 : 11 - resto;
  if (dig1 !== parseInt(cnpj.charAt(12))) return false;

  // Segundo dígito verificador
  soma = 0;
  for (let i = 0; i < 13; i++) {
    soma += parseInt(cnpj.charAt(i)) * peso2[i];
  }
  resto = soma % 11;
  const dig2 = resto < 2 ? 0 : 11 - resto;
  if (dig2 !== parseInt(cnpj.charAt(13))) return false;

  return true;
}

// Exemplos
console.log(validarCNPJ('11.222.333/0001-81')); // true
console.log(validarCNPJ('11.111.111/1111-11')); // false

Implementação em Python

def validar_cnpj(cnpj: str) -> bool:
    # Remove caracteres não numéricos
    cnpj = ''.join(filter(str.isdigit, cnpj))

    # Verifica se tem 14 dígitos
    if len(cnpj) != 14:
        return False

    # Rejeita CNPJs com todos os dígitos iguais
    if cnpj == cnpj[0] * 14:
        return False

    # Pesos oficiais
    peso1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
    peso2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]

    # Primeiro dígito verificador
    soma = sum(int(cnpj[i]) * peso1[i] for i in range(12))
    resto = soma % 11
    dig1 = 0 if resto < 2 else 11 - resto
    if dig1 != int(cnpj[12]):
        return False

    # Segundo dígito verificador
    soma = sum(int(cnpj[i]) * peso2[i] for i in range(13))
    resto = soma % 11
    dig2 = 0 if resto < 2 else 11 - resto
    if dig2 != int(cnpj[13]):
        return False

    return True

# Exemplos
print(validar_cnpj('11.222.333/0001-81'))  # True
print(validar_cnpj('00.000.000/0000-00'))  # False

Implementação em Java

public class CNPJValidator {
    private static final int[] PESO1 = {5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2};
    private static final int[] PESO2 = {6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2};

    public static boolean validar(String cnpj) {
        cnpj = cnpj.replaceAll("\\D", "");

        if (cnpj.length() != 14) return false;
        if (cnpj.matches("(\\d)\\1{13}")) return false;

        // Primeiro dígito verificador
        int soma = 0;
        for (int i = 0; i < 12; i++) {
            soma += Character.getNumericValue(cnpj.charAt(i)) * PESO1[i];
        }
        int resto = soma % 11;
        int dig1 = resto < 2 ? 0 : 11 - resto;
        if (dig1 != Character.getNumericValue(cnpj.charAt(12))) return false;

        // Segundo dígito verificador
        soma = 0;
        for (int i = 0; i < 13; i++) {
            soma += Character.getNumericValue(cnpj.charAt(i)) * PESO2[i];
        }
        resto = soma % 11;
        int dig2 = resto < 2 ? 0 : 11 - resto;
        if (dig2 != Character.getNumericValue(cnpj.charAt(13))) return false;

        return true;
    }
}

CNPJ vs CPF: Diferenças na Validação

Erros Comuns na Validação de CNPJ

1. Não rejeitar dígitos repetidos: CNPJs como 11.111.111/1111-11 passam no módulo 11 por coincidência matemática.
2. Confundir máscara com valor: Sempre limpe a string antes de validar (replace(/\D/g, '')).
3. Ignorar o número de ordem: CNPJs com ordem 0000 são inválidos (deve ser pelo menos 0001).
4. Usar dados reais em testes: Use geradores de CNPJ para criar dados fictícios válidos.

Perguntas Frequentes

Qual a diferença entre CNPJ de matriz e filial?

Os dígitos 9 a 12 do CNPJ indicam a ordem do estabelecimento. 0001 é sempre a matriz, e a partir de 0002 são filiais. Todos compartilham a mesma raiz (dígitos 1–8).

Posso consultar se um CNPJ existe de verdade?

Sim, através da API da ReceitaWS ou do site oficial da Receita Federal. A validação matemática apenas verifica se o número é estruturalmente correto, não se está de fato cadastrado.

Um CNPJ gerado por ferramenta pode ser usado em nota fiscal?

Não. CNPJs gerados são para testes de software apenas. Usar um CNPJ fictício em documentos fiscais reais é crime de falsidade ideológica.