Gerador de CNPJ — Numérico, Alfanumérico 2026 e Validador

Gerador de CNPJ Online — Numérico, Alfanumérico (2026), Filiais e Validador

Gere CNPJs matematicamente válidos no formato clássico (numérico) e no novo formato alfanumérico que entra em vigor em julho de 2026. Crie hierarquias de matriz + filiais coerentes, gere empresas completas fictícias com razão social, CNAE e endereço, e valide qualquer CNPJ existente em tempo real. Tudo no browser, sem enviar dados para servidores — conformidade com a LGPD por arquitetura.

Esta ferramenta também suporta EIN (EUA), NIPC (Portugal), CIF (Espanha), Partita IVA (Itália), USt-IdNr (Alemanha) e SIREN/SIRET (França).

Como Usar o Gerador de CNPJ

Gerar um CNPJ válido leva três segundos:

1. Selecione o país — Clique na aba com a bandeira desejada. A aba CNPJ (Brasil) vem selecionada por padrão.
2. Configure o formato — Escolha entre Numérico (clássico) ou Alfanumérico (novo formato 2026). Selecione também se quer gerar a Matriz (0001) ou uma hierarquia com Filiais (0002, 0003...).
3. Clique em Gerar — O CNPJ aparece instantaneamente com a empresa completa fictícia: razão social, CNAE, endereço e sócio administrador.
4. Copie ou exporte — Clique no ícone de cópia ou pressione Shift+Enter para copiar para a área de transferência.

Para validar um CNPJ existente, cole-o no campo Validador em Tempo Real — o resultado aparece imediatamente com o detalhamento dos dígitos verificadores.

Exemplos de CNPJ

Caso especial — hierarquia matriz/filial: Os 8 primeiros dígitos (raiz) são os mesmos para a empresa inteira. Apenas os 4 dígitos de ordem (0001, 0002...) e os dígitos verificadores mudam. Use o modo Filial para gerar uma hierarquia coerente de uma vez só.

O Que É o CNPJ e Como Funciona o Algoritmo

O Cadastro Nacional da Pessoa Jurídica (CNPJ) é o número de identificação de empresas e pessoas jurídicas no Brasil, administrado pela Receita Federal. É composto por 14 caracteres divididos em três partes: raiz (8 dígitos, identifica a empresa), ordem (4 dígitos, identifica o estabelecimento) e dígitos verificadores (2 dígitos, calculados pelo Módulo 11).

Algoritmo Módulo 11 (dígito verificador 1): Pesos: 5,4,3,2,9,8,7,6,5,4,3,2. Multiplica os 12 primeiros caracteres, soma os produtos. Resto = soma mod 11. Se resto < 2, dígito = 0; senão, dígito = 11 − resto.

O novo CNPJ alfanumérico (julho 2026): A Receita Federal iniciará a emissão de CNPJs com letras A–Z nos primeiros 12 caracteres a partir de julho/2026. O Brasil está esgotando o espaço numérico disponível com milhões de CNPJs emitidos por ano. No novo formato, o valor de cada caractere para o cálculo do dígito verificador é o seu código ASCII menos 48 — dígitos 0–9 continuam valendo 0–9 e letras valem A=17, B=18, … Z=42. Foi exatamente essa escolha que garantiu que todos os CNPJs numéricos existentes mantivessem os mesmos dígitos verificadores.

Como identificar matriz vs. filial: Os dígitos de ordem (posições 9–12) indicam o tipo: 0001 = matriz; 0002, 0003, etc. = filiais. A raiz (primeiros 8 dígitos) é a mesma para toda a hierarquia da empresa.

Casos de Uso Comuns

• Testes de formulários e APIs: Preencha bases de dados de teste, mock de APIs e testes de formulário com CNPJs válidos sem usar dados empresariais reais.
• QA de ERP e sistemas fiscais: Gere hierarquias de matriz + filiais para testar sistemas que precisam processar empresas com múltiplos estabelecimentos — NF-e, billing, SPED.
• Conformidade com a LGPD: Usar dados empresariais reais em ambientes de desenvolvimento viola a LGPD. CNPJs gerados são matematicamente válidos mas não cadastrados na Receita Federal — proteção legal por arquitetura.
• Empresa completa fictícia para QA: A ferramenta gera razão social, CNAE, endereço completo e sócio administrador com CPF — tudo necessário para testar cadastros empresariais de ponta a ponta.
• Novo formato 2026 antecipado: Teste seus sistemas com o novo formato alfanumérico antes da obrigatoriedade — garanta que seus validadores, formulários e bancos de dados suportam letras no CNPJ.

Erros Comuns ao Gerar CNPJs

• Usar CNPJ com todos os dígitos iguais como dado de teste válido: 11.111.111/1111-11 é inválido por definição do algoritmo. Serve para testar o caminho de erro, não o caminho feliz.
• Confundir CPF e CNPJ: CPF (11 dígitos) identifica pessoas físicas; CNPJ (14 caracteres) identifica pessoas jurídicas. Ambos usam Módulo 11 mas com pesos diferentes.
• Gerar CNPJs aleatórios para hierarquias: CNPJs gerados sem o modo Filial terão raízes diferentes e não serão reconhecidos como a mesma empresa em sistemas fiscais. Use o modo Matriz + Filiais para gerar hierarquias coerentes.

Perguntas Frequentes

O CNPJ gerado pertence a alguma empresa real?

Não. O gerador cria números que seguem o algoritmo oficial (Módulo 11) e passam em qualquer validação matemática, mas não estão cadastrados na base da Receita Federal. São fictícios e não identificam nenhuma empresa.

Quando o CNPJ muda para o formato alfanumérico?

A partir de julho de 2026, a Receita Federal iniciará a emissão de CNPJs no novo formato alfanumérico, com letras A–Z nos primeiros 12 caracteres. O algoritmo Módulo 11 continua sendo usado, com o valor de cada caractere definido como código ASCII − 48 (A=17, B=18, … Z=42). CNPJs numéricos existentes permanecem válidos indefinidamente.

Como gerar um CNPJ de filial a partir de um CNPJ de matriz?

Os 8 primeiros dígitos (raiz) são os mesmos para matriz e filiais. Para gerar uma filial, use a mesma raiz com dígitos de ordem diferentes (0002, 0003...) e recalcule os dígitos verificadores pelo Módulo 11. O modo "Filial" desta ferramenta faz isso automaticamente.

O que significa o CNPJ alfanumérico e como funciona o algoritmo?

No novo formato, os 12 primeiros caracteres podem incluir letras maiúsculas A–Z além dos dígitos 0–9. Para o cálculo do dígito verificador, o valor de cada caractere é o seu código ASCII menos 48: dígitos 0–9 valem 0–9 e letras valem A=17, B=18, C=19, … Z=42. Atenção: não é a conversão base 36 (A=10) — usar A=10 gera dígitos verificadores errados. O resto do algoritmo Módulo 11 permanece igual ao formato clássico.

O validador verifica se o CNPJ está cadastrado na Receita Federal?

Não. O validador verifica apenas a validade matemática — se os dígitos verificadores estão corretos segundo o Módulo 11. Um CNPJ matematicamente válido pode ou não estar cadastrado na Receita Federal. Para consultar dados reais de empresas, use o portal da Receita Federal.

Como Validar CNPJ em Código

O algoritmo Módulo 11 abaixo funciona para o formato clássico numérico e para o novo formato alfanumérico de julho de 2026. A única adaptação para o formato alfanumérico: cada caractere é convertido pelo seu código ASCII menos 48 (dígitos 0–9 → 0–9; letras A=17, B=18, … Z=42) antes da multiplicação pelos pesos. Cuidado com implementações que usam base 36 (A=10, … Z=35) — elas produzem dígitos verificadores incompatíveis com a especificação oficial da Receita. O restante do algoritmo é idêntico.

Fonte: Receita Federal — Especificação Técnica do CNPJ

JavaScript

function cnpjCharValue(c) {
  return c.charCodeAt(0) - 48; // 0–9 → 0–9; A=17 … Z=42 (spec oficial RFB)
}

function validarCNPJ(input) {
  const cnpj = input.replace(/[.\-\/]/g, '').toUpperCase();
  if (cnpj.length !== 14) return false;

  // Rejeita sequências com todos os dígitos iguais (11111111111111 etc.)
  if (/^\d+$/.test(cnpj) && new Set(cnpj).size === 1) return false;

  const p1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
  let soma = p1.reduce((acc, p, i) => acc + cnpjCharValue(cnpj[i]) * p, 0);
  const d1 = soma % 11 < 2 ? 0 : 11 - (soma % 11);

  const p2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
  soma = p2.reduce((acc, p, i) => acc + cnpjCharValue(cnpj[i]) * p, 0);
  const d2 = soma % 11 < 2 ? 0 : 11 - (soma % 11);

  return cnpjCharValue(cnpj[12]) === d1 && cnpjCharValue(cnpj[13]) === d2;
}

console.log(validarCNPJ('45.892.112/0001-90')); // true
console.log(validarCNPJ('AB.C34.5D6/0001-04')); // true — alfanumérico 2026
console.log(validarCNPJ('11.111.111/1111-11')); // false

Python

import re

def cnpj_char_value(c: str) -> int:
    return ord(c.upper()) - 48  # 0-9 -> 0-9; A=17 ... Z=42 (spec oficial RFB)

def validar_cnpj(input_str: str) -> bool:
    cnpj = re.sub(r'[.\-/]', '', input_str).upper()
    if len(cnpj) != 14:
        return False

    if cnpj.isdigit() and len(set(cnpj)) == 1:
        return False

    p1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
    soma = sum(cnpj_char_value(cnpj[i]) * p1[i] for i in range(12))
    d1 = 0 if soma % 11 < 2 else 11 - (soma % 11)

    p2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
    soma = sum(cnpj_char_value(cnpj[i]) * p2[i] for i in range(13))
    d2 = 0 if soma % 11 < 2 else 11 - (soma % 11)

    return cnpj_char_value(cnpj[12]) == d1 and cnpj_char_value(cnpj[13]) == d2

print(validar_cnpj('45.892.112/0001-90'))  # True
print(validar_cnpj('AB.C34.5D6/0001-04'))  # True — alfanumérico 2026
print(validar_cnpj('11.111.111/1111-11'))  # False

PHP

function cnpjCharValue(string $c): int {
    return ord(strtoupper($c)) - 48; // 0-9 => 0-9; A=17 … Z=42 (spec oficial RFB)
}

function validarCNPJ(string $input): bool {
    $cnpj = strtoupper(preg_replace('/[.\-\/]/', '', $input));
    if (strlen($cnpj) !== 14) return false;

    if (ctype_digit($cnpj) && strlen(count_chars($cnpj, 3)) === 1) return false;

    $p1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
    $soma = 0;
    for ($i = 0; $i < 12; $i++) $soma += cnpjCharValue($cnpj[$i]) * $p1[$i];
    $d1 = ($soma % 11 < 2) ? 0 : 11 - ($soma % 11);

    $p2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
    $soma = 0;
    for ($i = 0; $i < 13; $i++) $soma += cnpjCharValue($cnpj[$i]) * $p2[$i];
    $d2 = ($soma % 11 < 2) ? 0 : 11 - ($soma % 11);

    return cnpjCharValue($cnpj[12]) === $d1 && cnpjCharValue($cnpj[13]) === $d2;
}

var_dump(validarCNPJ('45.892.112/0001-90')); // bool(true)
var_dump(validarCNPJ('AB.C34.5D6/0001-04')); // bool(true) — alfanumérico 2026
var_dump(validarCNPJ('11.111.111/1111-11')); // bool(false)

Recursos

• Receita Federal — Comprovante de Inscrição no CNPJ — Portal oficial para consulta e verificação de CNPJs cadastrados.
• Receita Federal — Instrução Normativa CNPJ Alfanumérico — Regulamentação oficial do novo formato alfanumérico do CNPJ a partir de julho de 2026.
• Gerador de CPF — Gere e valide CPF (Brasil), NIF (Portugal), DNI (Espanha), Codice Fiscale (Itália) e NIR (França) para testes de desenvolvimento.