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ções | O que identificam | Aceita letras? |
|---|---|---|
| 1 a 8 | Raiz: a empresa | Sim |
| 9 a 12 | Ordem: matriz ou filial | Sim |
| 13 e 14 | Dígitos verificadores | Nã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:
| Caractere | ASCII | Valor no cálculo |
|---|---|---|
0 | 48 | 0 |
9 | 57 | 9 |
A | 65 | 17 |
B | 66 | 18 |
Z | 90 | 42 |
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/