-1
oportunidados
5 min de leitura ·

CNPJ alfanumérico: o que muda no seu sistema e como validar o dígito

Desde 2026 a Receita Federal emite CNPJs alfanuméricos. As oito posições da raiz e as quatro da ordem podem conter letras e dígitos. Os dois dígitos verificadores continuam numéricos.

Um CNPJ numérico virou um caso particular do formato novo. Os CNPJs que já existem não mudam de número e continuam válidos. Nenhuma base precisa de migração de dados. O trabalho é outro: aceitar letras onde o sistema só aceitava dígito.

Se o seu cadastro valida com ^\d{14}$, guarda em coluna numérica ou usa máscara fixa de dígito, ele vai rejeitar documento válido. Este artigo mostra o formato, o que quebra, a regra do dígito com um exemplo calculado passo a passo e como a API do cnpj.ia.br trata os dois formatos.

O formato

PartePosiçõesConteúdo
Raiz1 a 8Letras maiúsculas ou dígitos. Identifica a empresa, comum a matriz e filiais.
Ordem9 a 12Letras maiúsculas ou dígitos. Identifica o estabelecimento.
Dígitos verificadores13 e 14Sempre numéricos. Módulo 11 sobre o valor ASCII menos 48 de cada posição anterior.

Dois exemplos. Numérico: 00.000.000/0001-91, do Banco do Brasil. Alfanumérico: 12.ABC.345/01DE-35, exemplo de formato do contrato da API.

O formato antigo continua válido, os números existentes não mudam, e a rotina nova aceita os dois formatos. Quem atualiza a validação uma vez cobre o estoque e o fluxo novo.

Por que bigint quebra e varchar(14) sobrevive

Três motivos, em ordem de dano.

1. Letras não cabem em número. 12ABC34501DE35 não é inteiro. A primeira inserção de um CNPJ alfanumérico em coluna BIGINT ou NUMERIC(14) falha. Em alguns modos de banco, pior: trunca em silêncio e grava lixo.

2. Zero à esquerda some. 00000000000191 como inteiro vira 191. Toda leitura precisa reaplicar padding com LPAD, e toda comparação direta com string falha sem aviso.

3. Pontuação varia. 00.000.000/0001-91 e 00000000000191 são a mesma empresa em duas strings distintas. Coluna numérica resolve esse caso por acidente e quebra nos dois anteriores.

A forma que sobrevive: texto de 14 caracteres, maiúsculas, sem pontuação. O fluxo de entrada fica assim:

  1. Converte para maiúsculas.
  2. Remove pontos, barra, hífen e espaços.
  3. Valida comprimento (14) e dígitos verificadores.
  4. Guarda na forma normalizada. Formata só na exibição.

Máscaras de entrada no padrão ##.###.###/####-## passam a aceitar letras nas doze primeiras posições. Os dois últimos campos continuam numéricos. Comparações e chaves estrangeiras usam a forma normalizada que a API devolve.

Procure no código por \d{14}, isdigit, parseInt, BIGINT e máscara fixa de dígito. Cada ocorrência é um ponto que rejeita ou corrompe CNPJ alfanumérico.

A regra do dígito verificador

Módulo 11, em duas passadas. A regra nova coincide com a antiga quando só há dígitos. A diferença: cada caractere entra na soma pelo seu valor ASCII menos 48. Dígitos valem 0 a 9. Letras maiúsculas valem 17 (A) a 42 (Z).

Primeira passada: multiplique os doze primeiros caracteres pelos pesos 5 4 3 2 9 8 7 6 5 4 3 2 e some. Tire o resto da divisão por 11. Resto menor que 2 dá dígito 0. Senão, o dígito é 11 − resto. Esse é o primeiro verificador.

Segunda passada: repita com os treze caracteres (os doze mais o primeiro verificador) e os pesos 6 5 4 3 2 9 8 7 6 5 4 3 2. O resultado é o segundo verificador.

Se o par calculado bate com o par informado, o formato é válido. Dígito certo não prova existência; prova que o número passou na checagem. Sequências repetidas, como 00000000000000, passam no cálculo e são rejeitadas à parte.

Exemplo passo a passo: 12ABC34501DE35

Normalizado (sem pontuação, maiúsculas): 12ABC34501DE35. Valores de cada caractere (ASCII − 48):

Caractere12ABC34501DE
Valor12171819345012021

Primeira passada, 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 mod 11 = 8 → primeiro dígito = 11 − 8 = 3

Segunda passada, com o 3 calculado e pesos 6 5 4 3 2 9 8 7 6 5 4 3 2:

1×6 + 2×5 + 17×4 + 18×3 + 19×2 + 3×9 + 4×8 + 5×7 + 0×6 + 1×5 + 20×4 + 21×3 + 3×2
= 6 + 10 + 68 + 54 + 38 + 27 + 32 + 35 + 0 + 5 + 80 + 63 + 6
= 424
424 mod 11 = 6 → segundo dígito = 11 − 6 = 5

Par calculado 35. Par informado 35. Formato válido.

Código

Python, curto, sem dependência:

PESOS_1 = (5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2)
PESOS_2 = (6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2)

def _dv(soma: int) -> int:
    resto = soma % 11
    return 0 if resto < 2 else 11 - resto

def cnpj_valido(cnpj: str) -> bool:
    n = cnpj.upper().replace(".", "").replace("/", "").replace("-", "").strip()
    if len(n) != 14 or len(set(n)) == 1:
        return False
    vals = [ord(c) - 48 for c in n[:12]]
    d1 = _dv(sum(v * p for v, p in zip(vals, PESOS_1)))
    d2 = _dv(sum(v * p for v, p in zip([*vals, d1], PESOS_2)))
    return n[12:] == f"{d1}{d2}"

cnpj_valido("12.ABC.345/01DE-35") devolve True. cnpj_valido("00.000.000/0001-91") devolve True. cnpj_valido("00.000.000/0001-92"), com o último dígito trocado, devolve False.

Roda em microssegundos, sem rede: elimina erro de digitação no formulário e separa linhas inválidas no lote antes de gastar consulta.

Como a API do cnpj.ia.br trata o formato

A API aceita o formato antigo e o novo, com ou sem pontuação, minúsculas ou maiúsculas. Remove pontos, barra e hífen antes de validar, valida os dígitos pelo algoritmo alfanumérico e devolve cnpj e raiz_cnpj normalizados. Nada muda nos endpoints nem nos créditos.

# numérico, com e sem pontuação: a mesma empresa
curl "https://api.cnpj.ia.br/v1/cnpjs/00000000000191" -H "Authorization: Bearer $CNPJIA_KEY"
curl "https://api.cnpj.ia.br/v1/cnpjs/00.000.000/0001-91" -H "Authorization: Bearer $CNPJIA_KEY"

# alfanumérico (exemplo de formato do contrato)
curl "https://api.cnpj.ia.br/v1/cnpjs/12.ABC.345/01DE-35" -H "Authorization: Bearer $CNPJIA_KEY"

Resposta resumida para o Banco do Brasil, perfil full:

{
  "data": {
    "cnpj": "00000000000191",
    "razao_social": "BANCO DO BRASIL SA",
    "situacao_cadastral": { "codigo": "02", "descricao": "Ativa" },
    "socios": [
      { "nome": "NOME DO DIRIGENTE", "cnpj_cpf_socio": "***123456**" }
    ]
  },
  "meta": {
    "profile": "full",
    "source": "rfb_open_data+oportunidados",
    "data_as_of": "2026-08-01",
    "credits_charged": 6
  }
}

Quatro comportamentos para a sua integração:

  • Formato ou dígito inválido responde 400 invalid_cnpj, sem custo.
  • CNPJ válido que não existe na base responde 404 not_found, também sem custo.
  • Toda resposta informa a data da base em meta.data_as_of. A base é a da Receita Federal, atualizada mensalmente.
  • CPF de sócio sai mascarado ou nulo, nunca completo.

O basic custa 1 crédito; o full, 6. O plano gratuito inclui 60 créditos por mês.

Detalhe do formato e dos campos: CNPJ alfanumérico na API.

Publicado originalmente em https://cnpj.ia.br/docs/cnpj-alfanumerico?utm_source=tabnews&utm_medium=article.

Carregando publicação patrocinada...