CNPJ alfanumérico

O CNPJ passou a aceitar letras nas 12 primeiras posições. Os dois dígitos verificadores continuam numéricos, o tamanho continua 14 e a máscara continua 00.000.000/0000-00. O cálculo do DV é o mesmo módulo 11 de sempre — a única diferença é que o valor de cada caractere passa a ser o código ASCII menos 48.

O que mudou, exatamente

A lista de "igual" é maior que a de "mudou", e isso é o ponto mais importante do planejamento: não é uma reescrita, é a remoção de uma premissa. A premissa de que cada posição do CNPJ é um dígito está espalhada pelo seu sistema em tipos de coluna, regex, máscaras de input, parseInt, comparações e contratos de API — e é isso que precisa ser encontrado.

O algoritmo do dígito verificador

1. Normalize: maiúsculas, sem máscara. Sobram 14 caracteres.
2. Converta cada um dos 12 primeiros em número: valor = código ASCII − 48.
3. Multiplique pelos pesos do 1º DV: 5 4 3 2 9 8 7 6 5 4 3 2. Some.
4. Divida por 11. Se o resto for menor que 2, o DV é 0; senão é 11 − resto.
5. Repita com as 13 posições (as 12 + o 1º DV) e os pesos do 2º DV: 6 5 4 3 2 9 8 7 6 5 4 3 2.

Tabela de conversão: caractere → valor

Exemplo completo

Base AB12CD34EFGH, calculando o 1º DV. Os valores saem da tabela acima:

Soma = 850. 850 ÷ 11 deixa resto 3. Como 3 ≥ 2, o 1º DV é 11 − 3 = 8. Repetindo com 13 posições (AB12CD34EFGH8) e os pesos do 2º DV, chega-se a 3. Resultado: AB.12C.D34/EFGH-83.

Implementação

Uma função só, que atende numérico e alfanumérico. Esta é exatamente a rotina que roda no validador desta página:

const PESOS_DV1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
const PESOS_DV2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];

const valor = (ch) => ch.charCodeAt(0) - 48;   // '0'->0 ... '9'->9, 'A'->17 ... 'Z'->42

function dv(base, pesos) {
  const soma = pesos.reduce((s, p, i) => s + valor(base[i]) * p, 0);
  const resto = soma % 11;
  return resto < 2 ? 0 : 11 - resto;
}

export function validarCNPJ(entrada) {
  const s = String(entrada).toUpperCase().replace(/[^0-9A-Z]/g, '');

  // 12 alfanuméricos + 2 dígitos verificadores NUMÉRICOS
  if (!/^[0-9A-Z]{12}[0-9]{2}$/.test(s)) return false;
  if (/^(.)\1{13}$/.test(s)) return false;      // caractere repetido nunca é válido

  const d1 = dv(s, PESOS_DV1);
  const d2 = dv(s.slice(0, 12) + d1, PESOS_DV2);
  return s.slice(12) === `${d1}${d2}`;
}

validarCNPJ('AB.12C.D34/EFGH-83');   // true
validarCNPJ('00.000.000/0001-91');   // true — numérico continua funcionando

Expressão regular

# Sem máscara, 14 posições
^[0-9A-Z]{12}[0-9]{2}$

# Com máscara opcional
^([0-9A-Z]{2})\.?([0-9A-Z]{3})\.?([0-9A-Z]{3})\/?([0-9A-Z]{4})-?([0-9]{2})$

# O que você provavelmente tem hoje, e que passa a rejeitar CNPJ válido:
^\d{14}$
^[0-9]{2}\.[0-9]{3}\.[0-9]{3}\/[0-9]{4}-[0-9]{2}$

Regex valida formato, nunca dígito verificador. AB12CD34EFGH99 passa em qualquer regex acima e é um CNPJ inválido. Use a regex no input e o cálculo do DV na regra de negócio — os dois, não um.

Checklist de migração

Em ordem de risco. Os três primeiros são os que quebram em produção no dia em que o primeiro CNPJ com letra chega:

Quatro armadilhas

1. Guardar CNPJ em coluna numérica

É a falha mais comum e a mais silenciosa: o sistema funciona perfeitamente até o primeiro cadastro com letra, e aí o erro aparece no ponto mais distante da causa. Vale conferir hoje, não quando acontecer:

-- PostgreSQL: colunas cujo nome sugere CNPJ e cujo tipo é numérico
SELECT table_schema, table_name, column_name, data_type
FROM information_schema.columns
WHERE column_name ILIKE '%cnpj%'
  AND data_type IN ('integer','bigint','numeric','double precision','real','smallint');

-- MySQL / MariaDB
SELECT table_schema, table_name, column_name, column_type
FROM information_schema.columns
WHERE column_name LIKE '%cnpj%'
  AND data_type IN ('int','bigint','decimal','double','float','smallint');

2. Achar que precisa de duas rotinas de validação

Por causa do ASCII − 48, a rotina alfanumérica devolve o mesmo DV que a antiga para qualquer CNPJ numérico. Manter validarCnpjAntigo e validarCnpjNovo em paralelo cria duas fontes de verdade que vão divergir. Substitua por uma.

3. Esquecer a normalização de caixa

O DV é calculado sobre o código ASCII, então a (97) e A (65) dão valores diferentes e o DV não fecha. Um CNPJ digitado em minúsculas é válido para o usuário e inválido para o seu código, se você não normalizar. Faça toUpperCase() na entrada e grave em maiúsculas, para não acabar com o mesmo CNPJ em duas grafias na base.

4. Aceitar letra no dígito verificador

Uma regex frouxa como ^[0-9A-Z]{14}$ aceita AB12CD34EFGHIJ, que não é CNPJ: as duas últimas posições são sempre numéricas. Separe as duas partes no padrão — [0-9A-Z]{12}[0-9]{2} — e você rejeita isso no formato, sem nem chegar ao DV.

Gerar CNPJ alfanumérico para teste

Você vai precisar de massa de teste com letra antes de o primeiro caso real chegar. Sorteie as 12 posições e calcule o DV — nunca invente o DV, senão seus testes passam a validar o bug:

const ALFABETO = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';

function gerarCNPJ({ comLetras = true } = {}) {
  const fonte = comLetras ? ALFABETO : '0123456789';
  let base = '';
  for (let i = 0; i < 12; i++) {
    base += fonte[Math.floor(Math.random() * fonte.length)];
  }
  const d1 = dv(base, PESOS_DV1);
  const d2 = dv(base + d1, PESOS_DV2);
  return base + d1 + d2;
}

O validador no topo desta página mostra o cálculo passo a passo, posição por posição — útil para conferir a sua implementação contra a nossa quando o DV não fecha e você não sabe onde.