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

> O CNPJ alfanumérico mantém 14 posições, mas as 12 primeiras passam a aceitar letras de A a Z além de números, e os dois dígitos verificadores continuam numéricos. Este guia explica o que muda para quem desenvolve sistemas e traz funções testadas para validar CNPJ, numérico ou alfanumérico, em JavaScript, Python e PHP.

- Endereço oficial: https://pradev.com.br/guias/cnpj-alfanumerico-como-validar
- Tipo: Guia
- Publicado em: 2026-09-30
- Atualizado em: 2026-09-30
- Autor: Leonardo Gaertner (https://pradev.com.br/sobre)
- Ferramentas: [Validador de CNPJ](https://pradev.com.br/validador-de-cnpj), [Gerador de CNPJ](https://pradev.com.br/gerador-de-cnpj)

## 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.

```javascript
// 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',
  );
}
```

_JavaScript. Expressão do formato (novo e antigo) e máscara._

## 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.

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

_JavaScript. Funciona no navegador e no Node.js, sem dependências._

## Validar CNPJ em Python

```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])
```

_Python_

## Validar CNPJ em PHP

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

_PHP_

## Como testar

O [gerador de CNPJ](https://pradev.com.br/gerador-de-cnpj) cria números de teste nos dois formatos, e o [validador de CNPJ](https://pradev.com.br/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).

## Perguntas frequentes

### Os CNPJs atuais vão mudar?

Não. Os CNPJs já existentes continuam os mesmos, só com números. O formato alfanumérico vale para novas inscrições a partir de julho de 2026.

### As letras do CNPJ podem ser minúsculas?

O padrão usa letras maiúsculas. Converta para maiúsculas antes de validar e guardar, assim a mesma empresa não aparece duas vezes com grafias diferentes.

### Preciso trocar o tipo da coluna do CNPJ no banco de dados?

Se a coluna guarda o CNPJ como número, sim: ela precisa virar texto de 14 caracteres (CHAR ou VARCHAR). Se já é texto, basta ajustar as validações e as máscaras.

### Um validador antigo de CNPJ ainda funciona?

Para CNPJs numéricos, sim. Mas ele recusará qualquer CNPJ com letras, porque costuma exigir 14 dígitos numéricos. Atualize para uma função como a deste guia, que aceita os dois formatos.

## Fontes

- [Receita Federal: perguntas e respostas sobre o CNPJ alfanumérico](https://www.gov.br/receitafederal/pt-br/centrais-de-conteudo/publicacoes/perguntas-e-respostas/cnpj/cnpj-alfanumerico.pdf)

## Guias relacionados

- [Como validar CPF em JavaScript, Python e PHP](https://pradev.com.br/guias/como-validar-cpf-em-javascript): Aprenda a calcular os dígitos verificadores do CPF e veja funções prontas e testadas para validar CPF em JavaScript, Python e PHP.