-1

O CNPJ já tem letras desde julho de 2026, e o motivo de você ainda não ter percebido

O CNPJ alfanumérico entrou em vigor em julho de 2026. Não é previsão: está valendo. E a maior parte dos sistemas brasileiros ainda não sabe, por um motivo específico.

A Receita atribui os caracteres aleatoriamente. Uma empresa aberta hoje ainda pode receber um CNPJ totalmente numérico. Então o seu sistema não quebrou no dia 31 de julho com tudo pegando fogo, ele vai quebrar um cadastro por vez, em silêncio, conforme as inscrições com letra aparecem.

Isso é pior que quebrar de uma vez. Falha espalhada no tempo não vira incidente, vira dado errado no banco.

O formato

Continua com 14 posições e a mesma máscara. Muda o que é aceito em cada parte:

PosiçõesO que identificamAceita letras?
1 a 8Raiz: a empresaSim
9 a 12Ordem: matriz ou filialSim
13 e 14Dígitos verificadoresNão, seguem numéricos

Na prática, um CNPJ alfanumérico se parece com isto:

12.ABC.345/01DE-35

A base legal é a Instrução Normativa RFB nº 2.229, de 15 de outubro de 2024. O motivo é simples: com oito posições numéricas de raiz, o CNPJ comportava 100 milhões de combinações. Era muito em 1998.

Com as mesmas oito posições aceitando 0-9 e A-Z, o alfabeto sai de 10 para 36 caracteres e a conta vira 36^8, ou seja: 2.821.109.907.456 raízes, mais de 2,8 trilhões. Vinte e oito mil vezes mais espaço sem acrescentar uma única posição ao campo, o que é o detalhe que importa para quem mantém sistema: a largura continua 14.

Os CNPJs já emitidos continuam válidos, sem recadastramento e sem prazo. Ou seja: não é migração de formato. É o seu sistema passando a receber dois formatos para sempre.

O cálculo do dígito verificador

Essa é a parte que vale a leitura, porque é mais elegante do que eu esperava.

Continua sendo módulo 11 com os mesmos pesos. A única coisa que mudou é como cada caractere vira número antes de entrar na conta:

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

É isso. Código ASCII menos 48.

O 48 não é um número mágico escolhido a esmo: é a posição do caractere '0' na tabela ASCII. Então:

CaractereASCIIValor no cálculo
0480
9579
A6517
B6618
Z9042

Repare na consequência: os dígitos continuam valendo eles mesmos. '0' → 0, '9' → 9. O cálculo dos CNPJs antigos permanece byte a byte idêntico ao de antes, e as letras simplesmente entram na sequência a partir de 17. Compatibilidade retroativa de graça, com uma subtração.

Vamos conferir com a base 12ABC34501DE. Primeiro, converta cada caractere:

1   2   A   B   C   3   4   5   0   1   D   E
1   2  17  18  19   3   4   5   0   1  20  21

Primeiro dígito. Pesos 5 4 3 2 9 8 7 6 5 4 3 2:

1×5 + 2×4 + 17×3 + 18×2 + 19×9 + 3×8 + 4×7 + 5×6 + 0×5 + 1×4 + 20×3 + 21×2
 5  +  8  +  51  +  36  + 171  + 24  + 28  + 30  +  0  +  4  + 60  + 42   = 459

459 % 11 = 8    →    11 − 8 = 3    →    1º dígito = 3

Segundo dígito. Repete com treze caracteres (os doze mais o dígito que acabou de sair) e pesos 6 5 4 3 2 9 8 7 6 5 4 3 2:

soma = 424

424 % 11 = 6    →    11 − 6 = 5    →    2º dígito = 5

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

A exceção do CPF continua valendo igual: se o resto for 0 ou 1, o dígito é 0, não 11 − resto.

O que quebra no seu código

Antes da lista, um crédito que o dev brasileiro merece: você provavelmente já guarda CNPJ como texto. Não por causa do alfanumérico, mas sim por causa do zero à esquerda. O CNPJ do Banco do Brasil é 00.000.000/0001-91, e qualquer coluna numérica transforma isso em 191. Aprendemos cedo, geralmente na marra, a não guardar documento como inteiro.

Então a mudança de julho te pega com um dos cinco pontos abaixo já resolvido. Os outros quatro continuam de pé, e há uma ironia no primeiro.

1. A limpeza de máscara. O clássico:

cnpj.replace(/\D/g, "")   // apaga as letras junto com os pontos

Esse é o pior dos cinco, porque não dá erro. Ele mutila o documento e entrega um valor de 10 caracteres para a validação, que recusa. Você vai debugar a validação, e o bug está na linha anterior. O certo é remover só pontuação:

cnpj.replace(/[^0-9A-Z]/gi, "").toUpperCase()

E aqui está a ironia: essa linha é mais comum justamente em quem acertou o tipo da coluna. Guardar a string limpa é o padrão de quem armazena como texto, e tirar a máscara com \D é como quase todo mundo faz. Quem fez certo no banco é quem mais provavelmente tem a linha que mutila o documento.

2. Validação por regex. Qualquer ^\d{14}$ passa a recusar CNPJ válido.

3. Máscara de formulário. Campo configurado para aceitar só dígitos impede a digitação. O usuário não consegue nem errar.

4. Ordenação e comparação. Comparar CNPJ como número deixa de funcionar.

5. O tipo numérico, onde ele sobreviveu. BIGINT e NUMBER(14) simplesmente não aceitam letra. Se o seu projeto é dos que escaparam do zero à esquerda, ou herdou essa coluna de um sistema mais velho, precisa virar texto e aí vem o resto da conta: índice, chave estrangeira e todo CAST espalhado pelas queries.

Mas o caso mais sorrateiro é outro: a coluna é texto e o valor virou número no caminho. parseInt num DTO, campo numérico no JSON de uma integração, importação de CSV, Excel comendo o zero à esquerda de uma planilha que alguém exportou. O banco está certo e o dado chega errado. Esse já acontecia com o zero à esquerda; com letra, ele deixa de ser arredondamento e passa a ser erro de conversão.

Um detalhe de normalização que é fácil deixar passar: guarde sempre em maiúsculo. 'a' e 'A' têm códigos ASCII diferentes, logo dariam dígitos verificadores diferentes. O formato oficial usa maiúsculas.

Como testar hoje

Jogue 12.ABC.345/01DE-35 no seu formulário. É o exemplo que aparece na documentação do Serpro, então é um caso de teste razoável para começar.

Se o seu validador recusar, procure nessa ordem: a chamada que remove não-números, a regex de dígitos, a máscara do campo, e por último o tipo da coluna.

Eu mantenho um gerador e um validador que aceitam os dois formatos, se ajudar a montar massa de teste: https://onlinetools.com.br/pt/gerador-de-cnpj/

Carregando publicação patrocinada...