CNPJ alfanumérico: o que muda e como validar em código

O que é o CNPJ alfanumérico

O CNPJ alfanumérico é o novo formato do cadastro de empresas da Receita Federal. Ele continua com 14 posições, mas as 12 primeiras podem ter letras maiúsculas (A a Z) e números (0 a 9). Os dois últimos caracteres, os dígitos verificadores, continuam sendo só números.

As novas inscrições passam a usar o formato alfanumérico a partir de julho de 2026. Os CNPJs que já existem não mudam: continuam numéricos e válidos. Por isso, os sistemas precisam aceitar os dois formatos ao mesmo tempo.

Estrutura

• 8 caracteres da raiz (letras ou números).
• 4 caracteres da ordem do estabelecimento (letras ou números), como 0001 para a matriz.
• 2 dígitos verificadores (só números).

A máscara fica AA.AAA.AAA/AAAA-DD, em que A é letra ou número e D é número.

O que muda para quem desenvolve

• O CNPJ é texto, nunca número. Isso vale para a coluna do banco de dados, para a API e para o formulário.
• O tamanho fixo é de 14 caracteres sem pontuação e 18 com a máscara.
• A validação de formato passa de ^\d{14}$ para ^[A-Z0-9]{12}[0-9]{2}$.
• Normalize a entrada para letras maiúsculas antes de validar e guardar.
• Máscaras de formulário que só aceitam números precisam ser trocadas por máscaras alfanuméricas, e o teclado numérico do celular deixa de servir.
• Integrações e layouts de arquivo (CSV, notas fiscais, APIs de terceiros) que esperam só dígitos precisam ser revistos.
• Não dependa de ordem numérica do CNPJ: com letras, a ordenação como texto é diferente da ordenação numérica.

// Formato aceito pelo CNPJ novo (alfanumérico) e pelo antigo (só números):
// 12 caracteres (letras maiúsculas e números) seguidos de 2 dígitos verificadores numéricos
const formatoCNPJ = /^[A-Z0-9]{12}[0-9]{2}$/;

// Máscara: AA.AAA.AAA/AAAA-DD
function formatarCNPJ(cnpj) {
  return cnpj.replace(
    /^([A-Z0-9]{2})([A-Z0-9]{3})([A-Z0-9]{3})([A-Z0-9]{4})([0-9]{2})$/,
    '$1.$2.$3/$4-$5',
  );
}

Como o dígito verificador é calculado

O cálculo continua sendo o módulo 11 de antes, com uma diferença: como agora há letras, cada caractere vale o seu código ASCII menos 48. Assim, os números de 0 a 9 valem 0 a 9 (igual ao CNPJ numérico), a letra A vale 17, a B vale 18, e assim até o Z, que vale 42.

Os pesos vão de 2 a 9, da direita para a esquerda, e se repetem. Some os produtos, divida por 11 e olhe o resto: se for menor que 2, o dígito é 0; caso contrário, é 11 menos o resto. O segundo dígito repete a conta com 13 caracteres (os 12 da base mais o primeiro dígito).

Exemplo com 12.ABC.345/01DE-35

• Base: 1 2 A B C 3 4 5 0 1 D E, que valem 1, 2, 17, 18, 19, 3, 4, 5, 0, 1, 20 e 21.
• Pesos, da esquerda para a direita: 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3 e 2.
• Soma dos produtos: 459. O resto de 459 dividido por 11 é 8, então o primeiro dígito é 11 - 8 = 3.
• Com esse 3 incluído, e pesos de 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3 e 2: soma 424. O resto é 6, então o segundo dígito é 11 - 6 = 5.
• Resultado: 12.ABC.345/01DE-35.

Para CNPJs só com números, o resultado é idêntico ao do cálculo antigo, então uma única função cobre os dois formatos.

Validar CNPJ em JavaScript

Esta função aceita o CNPJ numérico e o alfanumérico, com ou sem máscara, em maiúsculas ou minúsculas.

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]);
}

Validar CNPJ em 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])

Validar CNPJ em 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];
}

Como testar

O gerador de CNPJ cria números de teste nos dois formatos, e o validador de CNPJ confere o resultado. Casos que a sua função deve acertar:

• Válidos: 11.222.333/0001-81, 11.444.777/0001-61 e 12.ABC.345/01DE-35 (este último é o exemplo da documentação da Receita Federal).
• Inválidos: 12.ABC.345/01DE-36 (dígito errado), 00.000.000/0000-00 (todos iguais) e 12.ABC.345/01DE-3A (dígito verificador com letra).