Valide ou gere CNPJs no formato atual (numérico) e no novo formato alfanumérico 2026. Filial configurável.
Informe um CNPJ ou gere novos
O CNPJ tem 14 caracteres: RR.RRR.RRR/FFFF-DD
✦ Novo Formato 2026
A partir de julho de 2026, os novos CNPJs terão os 8 primeiros caracteres da raiz alfanuméricos (letras A–Z e dígitos 0–9). Os 4 dígitos da filial e os 2 verificadores continuam numéricos. CNPJs antigos não mudam.
⚠️ CNPJs gerados são fictícios. Use apenas para testes de sistemas.
O CNPJ (Cadastro Nacional de Pessoas Jurídicas) é o número que identifica empresas,
associações, fundações e outros entes jurídicos perante a Receita Federal do Brasil.
Com 14 caracteres no formato XX.XXX.XXX/FFFF-DD,
divide-se em três partes com funções distintas:
O CNPJ usa módulo 11 com dois conjuntos de pesos cíclicos aplicados sobre os 12 primeiros dígitos (raiz + filial), gerando os 2 verificadores. Os pesos são descendentes e cíclicos: 5,4,3,2,9,8,7,6,5,4,3,2 para DV1 e 6,5,4,3,2,9,8,7,6,5,4,3,2 para DV2.
function validarCNPJ(cnpj) { cnpj = cnpj.replace(/\D/g, ''); if (cnpj.length !== 14) return false; if (/^(\d)\1+$/.test(cnpj)) return false; // ex: 00000000000000 const calcDV = (base, pesos) => { const soma = base.split('').reduce((s, d, i) => s + +d * pesos[i], 0); const r = soma % 11; return r < 2 ? 0 : 11 - r; }; const p1 = [5,4,3,2,9,8,7,6,5,4,3,2]; const p2 = [6,5,4,3,2,9,8,7,6,5,4,3,2]; const dv1 = calcDV(cnpj.slice(0,12), p1); const dv2 = calcDV(cnpj.slice(0,13), p2); return +cnpj[12] === dv1 && +cnpj[13] === dv2; } console.log(validarCNPJ('11.222.333/0001-81')); // true console.log(validarCNPJ('11222333000100')); // false
import re def validar_cnpj(cnpj: str) -> bool: cnpj = re.sub(r'\D', '', cnpj) if len(cnpj) != 14 or len(set(cnpj)) == 1: return False def calc_dv(base, pesos): soma = sum(int(d) * p for d, p in zip(base, pesos)) r = soma % 11 return 0 if r < 2 else 11 - r p1 = [5,4,3,2,9,8,7,6,5,4,3,2] p2 = [6,5,4,3,2,9,8,7,6,5,4,3,2] dv1 = calc_dv(cnpj[:12], p1) dv2 = calc_dv(cnpj[:13], p2) return int(cnpj[12]) == dv1 and int(cnpj[13]) == dv2
A partir de julho de 2026, novos CNPJs terão os 8 primeiros caracteres (raiz) compostos por letras maiúsculas (A–Z) e dígitos (0–9), em vez de apenas números. O algoritmo de validação é idêntico ao atual — a única diferença é que cada caractere precisa ser convertido para um valor numérico antes do cálculo: dígitos 0–9 mantêm seus valores, e letras A–Z recebem valores 10–35.
| Caractere | Valor numérico | Caractere | Valor numérico |
|---|---|---|---|
| 0–9 | 0–9 (mesmo valor) | A | 10 |
| B | 11 | C | 12 |
| D | 13 | E | 14 |
| F | 15 | G | 16 |
| H | 17 | I | 18 |
| J | 19 | K | 20 |
| L | 21 | M | 22 |
| N | 23 | O | 24 |
| P | 25 | Q | 26 |
| R | 27 | S | 28 |
| T | 29 | U | 30 |
| V | 31 | W | 32 |
| X | 33 | Y | 34 |
| Z | 35 | — | — |
// Converte caractere alfanumérico para valor numérico function charParaValor(c) { const code = c.toUpperCase().charCodeAt(0); return code >= 65 ? code - 55 : +c; // A=10, B=11 ... Z=35 } function validarCNPJ2026(cnpj) { // Remove formatação, mantém alfanumérico cnpj = cnpj.replace(/[.\-\/]/g, '').toUpperCase(); if (cnpj.length !== 14) return false; // Raiz: pos 0–7 alfanumérico; filial+DV: pos 8–13 numérico if (!/^[A-Z0-9]{8}\d{6}$/.test(cnpj)) return false; const vals = cnpj.split('').map(charParaValor); const calcDV = (base, pesos) => { const soma = base.reduce((s, v, i) => s + v * pesos[i], 0); const r = soma % 11; return r < 2 ? 0 : 11 - r; }; const p1 = [5,4,3,2,9,8,7,6,5,4,3,2]; const p2 = [6,5,4,3,2,9,8,7,6,5,4,3,2]; const dv1 = calcDV(vals.slice(0,12), p1); const dv2 = calcDV(vals.slice(0,13), p2); return vals[12] === dv1 && vals[13] === dv2; } console.log(validarCNPJ2026('AB.CDE.FGH/0001-XX')); // true/false (exemplo)
import re def char_para_valor(c: str) -> int: return ord(c) - 55 if c.isalpha() else int(c) # A=10...Z=35 def validar_cnpj_2026(cnpj: str) -> bool: cnpj = re.sub(r'[.\-/]', '', cnpj).upper() if len(cnpj) != 14: return False if not re.match(r'^[A-Z0-9]{8}\d{6}$', cnpj): return False vals = [char_para_valor(c) for c in cnpj] def calc_dv(base, pesos): soma = sum(v * p for v, p in zip(base, pesos)) r = soma % 11 return 0 if r < 2 else 11 - r p1 = [5,4,3,2,9,8,7,6,5,4,3,2] p2 = [6,5,4,3,2,9,8,7,6,5,4,3,2] dv1 = calc_dv(vals[:12], p1) dv2 = calc_dv(vals[:13], p2) return vals[12] == dv1 and vals[13] == dv2
| Característica | CNPJ | CPF |
|---|---|---|
| Total de dígitos | 14 | 11 |
| Dígitos verificadores | 2 (posições 13 e 14) | 2 (posições 10 e 11) |
| Pesos DV1 | 5,4,3,2,9,8,7,6,5,4,3,2 | 10,9,8,7,6,5,4,3,2 |
| Pesos DV2 | 6,5,4,3,2,9,8,7,6,5,4,3,2 | 11,10,9,8,7,6,5,4,3,2 |
| Regra resultado < 2 | DV = 0 | DV = 0 |
| Resultado ≥ 2 | DV = 11 − resto | DV = 11 − resto |
| Alfanumérico 2026 | ✦ Sim (raiz) | Não |
| Identifica | Pessoa jurídica | Pessoa física |
Não. CNPJs existentes permanecem com seus números numéricos originais para sempre. A mudança alfanumérica se aplica apenas a novos cadastros feitos a partir de julho de 2026. Sistemas que já validam CNPJ numérico continuarão funcionando normalmente para empresas existentes — mas precisarão ser atualizados para aceitar o novo formato em novos cadastros.
As mudanças necessárias nos sistemas são:
/^\d{14}$/ para /^[A-Z0-9]{8}\d{6}$/ (sem formatação)VARCHAR(14) já suportam — não precisa mudar schemaO algoritmo de verificação dos dígitos é idêntico — só muda o pré-processamento de conversão de caracteres.
A raiz do CNPJ são os 8 primeiros caracteres — identifica a empresa independentemente da filial. Todas as filiais de uma mesma empresa compartilham a mesma raiz, variando apenas os 4 dígitos da filial (0001, 0002, etc.).
Consultas por raiz são usadas para identificar todas as filiais de um grupo empresarial — útil em sistemas de crédito, compliance e análise fiscal.
Com 8 dígitos numéricos na raiz, o espaço de combinações é limitado a 100 milhões de raízes distintas (10⁸). O Brasil já tem mais de 55 milhões de CNPJs registrados e o crescimento acelerado de MEIs, startups e holdings está esgotando o espaço. Com 8 posições alfanuméricas (36 símbolos possíveis: 0–9 + A–Z), o espaço cresce para mais de 2,8 trilhões de combinações (36⁸) — suficiente para séculos de crescimento.
Existem APIs públicas e privadas para consulta de dados de CNPJ:
https://receitaws.com.br/v1/cnpj/{cnpj} — gratuita com limite de requisiçõeshttps://brasilapi.com.br/api/cnpj/v1/{cnpj} — gratuita, open sourceAs APIs públicas retornam razão social, situação cadastral, endereço, atividade principal (CNAE) e quadro societário. Para volumes altos, use as APIs com autenticação para evitar bloqueios por rate limiting.
14 caracteres: 8 raiz + 4 filial + 2 DV. Módulo 11 com pesos 5,4,3,2,9,8,7,6,5,4,3,2 (DV1) e 6,5,4,3,2,9,8,7,6,5,4,3,2 (DV2). Resultado < 2 → DV = 0; caso contrário DV = 11 − resto.
Novo formato julho 2026: raiz passa a ser alfanumérica (A–Z + 0–9). Conversão: A=10, B=11...Z=35. Algoritmo idêntico ao atual. CNPJs antigos não mudam.
Para adaptar sistemas: ajuste regex, campo de input e função de validação. Schema de banco VARCHAR(14) já suporta sem alteração.
Veja também