Gerador e validador de CNPJ alfanumérico

O que mudou de verdade

Desde 6 de julho de 2026 o CNPJ aceita letras. O documento continua com 14 caracteres e a mesma cara — o que muda é que as doze primeiras posições agora podem ser letra ou número, enquanto as duas últimas seguem sendo dígitos verificadores numéricos.

A expressão regular passa a ser [A-Z0-9]{12}[0-9]{2}. Só letras maiúsculas: o formato não usa minúsculas nem acentos.

O que não mudou

Todo CNPJ que existe hoje continua válido, com os mesmos dígitos verificadores. Empresa que já tem número não precisa trocar nada — as letras só aparecem nas inscrições novas, conforme forem sendo emitidas. E o algoritmo do dígito verificador é o mesmo módulo 11 de sempre, com um passo a mais antes dele.

Como o dígito verificador é calculado

O passo novo é converter cada caractere em número pelo código ASCII menos 48. Isso é escolhido de propósito: como '0' vale 48 na tabela ASCII, os algarismos continuam valendo eles mesmos, e por isso o cálculo antigo segue funcionando sem ajuste para CNPJ só de números.

Repare que não há caractere valendo de 10 a 16 — as letras começam em 17. Isso não é problema: o módulo 11 não exige que os valores sejam contínuos.

Passo a passo, com números reais

Vamos calcular os dois dígitos da raiz 12ABC34501DE. Os pesos vão de 2 a 9, ciclicamente, da direita para a esquerda.

Soma: 459. Resto de 459 por 11: 8. Como o resto é maior que 1, o dígito é 11 − 8, ou seja 3.

O segundo dígito repete o processo com treze caracteres — a raiz mais o dígito que acabou de sair. A soma dá 424, o resto por 11 dá 6, e o dígito é 11 − 6 = 5.

Resultado: 12.ABC.345/01DE-35

Código pronto

As três implementações abaixo passam no mesmo teste: validam CNPJ numérico real (Banco do Brasil 00000000000191, Petrobras 33000167000101) e geram alfanumérico que valida de volta.

JavaScript

const valor = (c) => c.charCodeAt(0) - 48;

function digito(base) {
  let peso = 2, soma = 0;
  for (let i = base.length - 1; i >= 0; i--) {
    soma += valor(base[i]) * peso;
    peso = peso < 9 ? peso + 1 : 2;
  }
  const resto = soma % 11;
  return resto < 2 ? 0 : 11 - resto;
}

export function validaCnpj(entrada) {
  const c = (entrada || '').toUpperCase().replace(/[^A-Z0-9]/g, '');
  if (!/^[A-Z0-9]{12}[0-9]{2}$/.test(c)) return false;

  const d1 = digito(c.slice(0, 12));
  const d2 = digito(c.slice(0, 12) + d1);
  return c.slice(12) === `${d1}${d2}`;
}

PHP

function valor(string $c): int
{
    return ord($c) - 48;
}

function digito(string $base): int
{
    $peso = 2;
    $soma = 0;

    for ($i = strlen($base) - 1; $i >= 0; $i--) {
        $soma += valor($base[$i]) * $peso;
        $peso = $peso < 9 ? $peso + 1 : 2;
    }

    $resto = $soma % 11;

    return $resto < 2 ? 0 : 11 - $resto;
}

function validaCnpj(string $entrada): bool
{
    $c = preg_replace('/[^A-Z0-9]/', '', strtoupper($entrada));

    if (!preg_match('/^[A-Z0-9]{12}[0-9]{2}$/', $c)) {
        return false;
    }

    $d1 = digito(substr($c, 0, 12));
    $d2 = digito(substr($c, 0, 12) . $d1);

    return substr($c, 12) === "{$d1}{$d2}";
}

Python

import re


def valor(c: str) -> int:
    return ord(c) - 48


def digito(base: str) -> int:
    peso, soma = 2, 0

    for c in reversed(base):
        soma += valor(c) * peso
        peso = peso + 1 if peso < 9 else 2

    resto = soma % 11

    return 0 if resto < 2 else 11 - resto


def valida_cnpj(entrada: str) -> bool:
    c = re.sub(r'[^A-Z0-9]', '', (entrada or '').upper())

    if not re.fullmatch(r'[A-Z0-9]{12}[0-9]{2}', c):
        return False

    d1 = digito(c[:12])
    d2 = digito(c[:12] + str(d1))

    return c[12:] == f'{d1}{d2}'

Os erros que vão aparecer no seu sistema

A coluna do banco

Se o CNPJ está guardado como número inteiro, ele para de caber. Precisa virar texto de 14 posições. E cuidado com quem guardava sem máscara em BIGINT para economizar espaço: a migração não é só de tipo, é de todo índice e chave estrangeira que depende dele.

A validação que só aceita dígito

Qualquer [0-9]{14} espalhado pelo código passa a rejeitar documento válido. Procure também por is_numeric, isdigit, parseInt e máscara de formulário — é onde costuma se esconder.

A ordenação e a comparação

Ordenar CNPJ como número deixa de funcionar. E comparar ignorando caixa é obrigatório: o formato é maiúsculo, então normalize a entrada antes de comparar, senão 12abc… e 12ABC… viram documentos diferentes.

Perguntas frequentes

Meu CNPJ atual deixa de valer?

Não. Todos os CNPJs existentes continuam válidos, com os mesmos dígitos verificadores. As letras aparecem apenas em inscrições novas.

Qual é a expressão regular do CNPJ alfanumérico?

[A-Z0-9]{12}[0-9]{2} — doze posições que aceitam letra maiúscula ou número, seguidas de dois dígitos verificadores numéricos.

Como o dígito verificador é calculado com letras?

Cada caractere vira número pelo código ASCII menos 48, o que dá 0 a 9 para os algarismos e 17 a 42 para as letras de A a Z. Depois é o módulo 11 de sempre, com pesos de 2 a 9 aplicados da direita para a esquerda.

Por que subtrair 48 e não usar A=10?

Porque com o menos 48 os algarismos continuam valendo eles mesmos, e o cálculo antigo segue produzindo o mesmo resultado para CNPJ só de números. É o que garante a retrocompatibilidade sem manter dois algoritmos.

O CNPJ alfanumérico usa letras minúsculas?

Não. Só maiúsculas de A a Z, sem acento e sem caractere especial. Normalize a entrada para maiúsculas antes de validar.

Este gerador cria CNPJ de empresa real?

Não. Ele produz combinações que passam na validação do dígito verificador, para uso em teste e desenvolvimento. Não consulta nem inventa dado cadastral de ninguém.

Os dados que eu colo aqui vão para algum servidor?

Não. Tudo é calculado no seu navegador, em JavaScript. Você pode desligar a internet depois de abrir a página e a ferramenta continua funcionando.