Validador de CNPJ (numérico e alfanumérico)

O validador de CNPJ confere se o número tem 14 caracteres e se os dois dígitos verificadores batem com o cálculo de módulo 11, aceitando tanto o CNPJ numérico tradicional quanto o novo CNPJ alfanumérico. Isso indica formato válido, mas não prova que a empresa existe.

Atualizado em · Por Leonardo Gaertner

Válido aqui quer dizer que os dois dígitos finais batem com o cálculo. Não prova que a empresa existe. O número digitado não sai do seu navegador.

Achou um resultado errado ou tem uma sugestão? Avise por e-mail.

Como usar

  1. Digite ou cole o CNPJ, com ou sem pontuação. Letras são aceitas.
  2. O resultado aparece assim que o número tiver 14 caracteres.
  3. Se for inválido, leia o motivo logo abaixo do campo.

Como funciona

O formato aceito é [A-Z0-9]{12}[0-9]{2}: doze caracteres entre números e letras maiúsculas seguidos de dois dígitos numéricos. A ferramenta ignora pontos, barra e traço e converte letras minúsculas para maiúsculas.

Cada caractere vira um valor: o código ASCII menos 48, de modo que 0 a 9 valem 0 a 9 e A a Z valem 17 a 42. Com pesos de 2 a 9 (da direita para a esquerda), soma-se, divide-se por 11 e o dígito é 0 se o resto for menor que 2, ou 11 menos o resto. O segundo dígito repete a conta incluindo o primeiro.

Este validador só verifica a regra matemática. Ele não consulta a Receita Federal, então não informa se a empresa existe, se está ativa ou qual é a razão social.

Fonte: Receita Federal: perguntas e respostas sobre o CNPJ alfanumérico

Em código

Para validar CNPJ no seu sistema, este código aceita o formato numérico e o alfanumérico e confere os dois dígitos verificadores.

JavaScript 
function validarCNPJ(valor) {
  const cnpj = String(valor).toUpperCase().replace(/[^0-9A-Z]/g, '');
  if (!/^[0-9A-Z]{12}[0-9]{2}$/.test(cnpj)) return false; // 12 caracteres + 2 dígitos
  if (/^(.)\1{13}$/.test(cnpj)) return false; // todos os caracteres iguais

  // Valor de cada caractere: código ASCII menos 48
  // ('0' a '9' valem 0 a 9, 'A' vale 17, 'B' vale 18...)
  const valorDoCaractere = (c) => c.charCodeAt(0) - 48;

  // Módulo 11 com pesos de 2 a 9, da direita para a esquerda
  const digito = (base) => {
    let soma = 0;
    let peso = 2;
    for (let i = base.length - 1; i >= 0; i--) {
      soma += valorDoCaractere(base[i]) * peso;
      peso = peso === 9 ? 2 : peso + 1;
    }
    const resto = soma % 11;
    return resto < 2 ? 0 : 11 - resto;
  };

  const d1 = digito(cnpj.slice(0, 12));
  const d2 = digito(cnpj.slice(0, 13));
  return d1 === Number(cnpj[12]) && d2 === Number(cnpj[13]);
}
Python 
import re


def validar_cnpj(valor: str) -> bool:
    cnpj = re.sub(r"[^0-9A-Z]", "", str(valor).upper())
    if not re.fullmatch(r"[0-9A-Z]{12}[0-9]{2}", cnpj):
        return False  # 12 caracteres + 2 dígitos
    if len(set(cnpj)) == 1:
        return False  # todos os caracteres iguais

    def digito(base: str) -> int:
        # Valor do caractere: ASCII menos 48. Pesos de 2 a 9, da direita para a esquerda
        soma, peso = 0, 2
        for caractere in reversed(base):
            soma += (ord(caractere) - 48) * peso
            peso = 2 if peso == 9 else peso + 1
        resto = soma % 11
        return 0 if resto < 2 else 11 - resto

    return digito(cnpj[:12]) == int(cnpj[12]) and digito(cnpj[:13]) == int(cnpj[13])
PHP 
<?php
function validarCnpj(string $valor): bool
{
    $cnpj = preg_replace('/[^0-9A-Z]/', '', strtoupper($valor));
    if (!preg_match('/^[0-9A-Z]{12}[0-9]{2}$/', $cnpj) || preg_match('/^(.)\1{13}$/', $cnpj)) {
        return false; // formato errado ou todos os caracteres iguais
    }

    // Valor do caractere: ASCII menos 48. Pesos de 2 a 9, da direita para a esquerda
    $digito = function (string $base): int {
        $soma = 0;
        $peso = 2;
        for ($i = strlen($base) - 1; $i >= 0; $i--) {
            $soma += (ord($base[$i]) - 48) * $peso;
            $peso = $peso === 9 ? 2 : $peso + 1;
        }
        $resto = $soma % 11;
        return $resto < 2 ? 0 : 11 - $resto;
    };

    return $digito(substr($cnpj, 0, 12)) === (int) $cnpj[12]
        && $digito(substr($cnpj, 0, 13)) === (int) $cnpj[13];
}

Perguntas frequentes

Validar um CNPJ confirma que a empresa existe?

Não. A validação confere apenas o formato e os dígitos verificadores. Para saber a situação cadastral de uma empresa, é preciso consultar a Receita Federal.

Este validador aceita CNPJ com letras?

Sim. Ele aceita o novo CNPJ alfanumérico da Receita Federal, com letras nas 12 primeiras posições e dígitos verificadores numéricos, além do CNPJ numérico tradicional.

Preciso digitar pontos, barra e traço?

Não. O campo aceita o CNPJ com ou sem pontuação.

O CNPJ que eu digito é enviado a algum servidor?

Não. A conferência é feita no seu navegador, e o número não é enviado nem armazenado pelo PraDev.

Guias sobre este assunto

Outras ferramentas que podem ajudar

Ver tudo em Documentos brasileiros