Artigo Build·Desenvolvimento·13 min de leitura de leitura

Como Gerar CNPJ Válido em JavaScript (2026): Algoritmo Passo a Passo

Q: Por que precisamos gerar CNPJ em vez de usar um real?

Três motivos. (1) Privacidade e LGPD: usar CNPJ real em testes ou demos expõe a empresa a vazamento de dado sensível. (2) Reprodutibilidade: você precisa controlar exatamente quais documentos aparecem em cada cenário de teste. (3) Volume: automação de testes exige milhares de CNPJs únicos — impossível obter licitamente. A geração local do algoritmo resolve os três sem depender de API externa.

Q: Qual o algoritmo para gerar CNPJ?

Gerar 12 dígitos (8 do número base + 4 do filial, sendo '0001' o padrão para matriz), calcular o primeiro dígito verificador via módulo 11 com pesos [5,4,3,2,9,8,7,6,5,4,3,2], calcular o segundo com pesos [6,5,4,3,2,9,8,7,6,5,4,3,2]. Em ambos, se o resultado for >= 10, o dígito é 0. O CNPJ final tem 14 dígitos: 8 base + 4 filial + 2 verificadores.

Gerar CNPJ válido em JavaScript é tarefa de 20 linhas e cobre 90% dos casos de teste em sistemas brasileiros. Este guia mostra o algoritmo do módulo 11 por completo, código pronto em TypeScript, geração em lote e as armadilhas de usar CNPJ real em ambiente de teste.

Por Vitor Morais

Fundador do MochaLabz · publicado em 20 de abril de 2026

🏢

Gere CNPJs em lote

Quantidade, formatação e download em CSV — tudo no navegador, sem cadastro.

Usar gerador →

Gerar CNPJ em JavaScript é um ritual de qualquer dev que trabalha com sistemas brasileiros. Ambientes de staging, testes automatizados, demos comerciais, seed de banco — todos exigem documentos válidos mas falsos. Usar CNPJ real em qualquer desses cenários é problema de LGPD esperando para acontecer; copiar CNPJ de gerador online é bom para 10 ou 20 documentos, não para 10 mil.

Este guia cobre o algoritmo completo (módulo 11 com pesos de CNPJ), código pronto em TypeScript, geração em lote com controle de unicidade e boas práticas de uso em testes. Ao final, você tem uma função confiável que roda em qualquer runtime JavaScript.

Anatomia do CNPJ

O CNPJ tem 14 dígitos no formato XX.XXX.XXX/XXXX-XX, divididos assim:

Estrutura do CNPJ
Critério	Posição	Significado
1 a 8	Dígitos 1-8	Número de registro da empresa
9 a 12	Dígitos 9-12	Código da filial (0001 = matriz)
13 e 14	Dígitos 13-14	Dígitos verificadores (módulo 11)

Para gerar um CNPJ válido, você só precisa sortear os 12 primeiros dígitos e calcular os dois últimos.

O algoritmo do módulo 11 aplicado ao CNPJ

O cálculo é idêntico ao do CPF em lógica, mas usa pesos diferentes por causa dos 12 dígitos base (em vez dos 9 do CPF).

Passo 1: sortear os 12 primeiros dígitos

// 8 dígitos do número base, aleatórios
const base = Array.from({ length: 8 }, () => Math.floor(Math.random() * 10));

// 4 dígitos do filial (use 0001 pra matriz)
const filial = [0, 0, 0, 1];

const twelve = [...base, ...filial];
// Ex: [4, 1, 2, 5, 6, 7, 8, 9, 0, 0, 0, 1]

Passo 2: calcular o primeiro dígito verificador

Multiplicar cada dos 12 dígitos por pesos específicos e somar:

// Pesos do primeiro dígito verificador
const weights1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];

let sum = 0;
for (let i = 0; i < 12; i++) {
  sum += twelve[i] * weights1[i];
}

const remainder1 = sum % 11;
const d1 = remainder1 < 2 ? 0 : 11 - remainder1;

Passo 3: calcular o segundo dígito verificador

Pesos estendidos para 13 dígitos (os 12 originais + o primeiro verificador):

// Pesos do segundo dígito verificador
const weights2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];

const thirteen = [...twelve, d1];
sum = 0;
for (let i = 0; i < 13; i++) {
  sum += thirteen[i] * weights2[i];
}

const remainder2 = sum % 11;
const d2 = remainder2 < 2 ? 0 : 11 - remainder2;

Dica

A regra “se o resto for < 2, o dígito é 0, caso contrário é 11 − resto” é a mesma do CPF. O que muda é apenas a sequência de pesos — porque o CNPJ tem mais dígitos base.

Função completa em TypeScript

/**
 * Gera um CNPJ válido aleatório.
 * @param options.filial Código da filial (padrão: "0001" = matriz)
 * @param options.formatado Retorna com formatação XX.XXX.XXX/XXXX-XX
 */
export function gerarCNPJ(options: {
  filial?: string;
  formatado?: boolean;
} = {}): string {
  const { filial = "0001", formatado = false } = options;

  // Validação do filial
  if (!/^\d{4}$/.test(filial)) {
    throw new Error("Filial deve ter exatamente 4 dígitos");
  }

  // Gera os 8 dígitos do número base
  const base = Array.from({ length: 8 }, () => Math.floor(Math.random() * 10));

  // Junta com o filial
  const twelve = [...base, ...filial.split("").map(Number)];

  // Calcula o primeiro dígito verificador
  const weights1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
  let sum = twelve.reduce((acc, d, i) => acc + d * weights1[i], 0);
  const r1 = sum % 11;
  const d1 = r1 < 2 ? 0 : 11 - r1;

  // Calcula o segundo dígito verificador
  const weights2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
  const thirteen = [...twelve, d1];
  sum = thirteen.reduce((acc, d, i) => acc + d * weights2[i], 0);
  const r2 = sum % 11;
  const d2 = r2 < 2 ? 0 : 11 - r2;

  const digits = [...thirteen, d2];
  const raw = digits.join("");

  if (!formatado) return raw;

  return `${raw.slice(0, 2)}.${raw.slice(2, 5)}.${raw.slice(5, 8)}/${raw.slice(
    8,
    12,
  )}-${raw.slice(12)}`;
}

// Uso
gerarCNPJ();
// "41256789000143"

gerarCNPJ({ formatado: true });
// "41.256.789/0001-43"

gerarCNPJ({ filial: "0042", formatado: true });
// "74839201/0042-87"

Geração em lote com controle de unicidade

Em seed de banco de dados e testes de volume, você normalmente precisa de N CNPJs únicos. Use Set para garantir ausência de duplicatas:

export function gerarCNPJsEmLote(
  quantidade: number,
  options?: { filial?: string; formatado?: boolean },
): string[] {
  const unicos = new Set<string>();

  while (unicos.size < quantidade) {
    unicos.add(gerarCNPJ(options));
  }

  return [...unicos];
}

// Gera 1000 CNPJs únicos formatados
const lote = gerarCNPJsEmLote(1000, { formatado: true });

// Exporta para CSV
const csv = "cnpj\n" + lote.join("\n");
console.log(csv);

Contexto

Para 1 milhão de CNPJs, ainda não há risco real de colisão (probabilidade matemática muito baixa). O Set é barato e protege de edge cases. O algoritmo gera ~10 milhões de CNPJs por segundo em hardware moderno — performance não é preocupação.

Gerando CNPJ em cenário específico: grupos de empresa

Em sistemas que modelam grupos empresariais (matriz + filiais), você gera um número base e várias filiais:

export function gerarGrupoEmpresa(
  numeroDeFiliais: number,
  options?: { formatado?: boolean },
): string[] {
  // Gera os 8 dígitos base aleatórios
  const base = Array.from({ length: 8 }, () => Math.floor(Math.random() * 10))
    .join("");

  const filiais = [
    "0001", // matriz
    ...Array.from({ length: numeroDeFiliais }, (_, i) =>
      String(i + 2).padStart(4, "0"),
    ),
  ];

  return filiais.map((f) => gerarCNPJEspecifico(base, f, options?.formatado));
}

function gerarCNPJEspecifico(
  base: string,
  filial: string,
  formatado = false,
): string {
  const twelve = (base + filial).split("").map(Number);

  const weights1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
  let sum = twelve.reduce((acc, d, i) => acc + d * weights1[i], 0);
  const r1 = sum % 11;
  const d1 = r1 < 2 ? 0 : 11 - r1;

  const weights2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
  const thirteen = [...twelve, d1];
  sum = thirteen.reduce((acc, d, i) => acc + d * weights2[i], 0);
  const r2 = sum % 11;
  const d2 = r2 < 2 ? 0 : 11 - r2;

  const raw = [...thirteen, d2].join("");

  if (!formatado) return raw;
  return `${raw.slice(0, 2)}.${raw.slice(2, 5)}.${raw.slice(5, 8)}/${raw.slice(
    8,
    12,
  )}-${raw.slice(12)}`;
}

// Uso: grupo com 5 filiais
gerarGrupoEmpresa(5, { formatado: true });
// [
//   "12.345.678/0001-XX",  // matriz
//   "12.345.678/0002-XX",  // filial 1
//   "12.345.678/0003-XX",  // filial 2
//   ...
// ]

Validando o que foi gerado

Todo CNPJ gerado precisa validar contra o módulo 11 — use função de validação (código no artigo “Como validar CPF e CNPJ em JavaScript”):

import { gerarCNPJ } from "./gerar-cnpj";
import { validarCNPJ } from "./validar-cnpj";

// Em um teste (Jest/Vitest)
describe("gerarCNPJ", () => {
  it("gera CNPJ válido módulo 11", () => {
    for (let i = 0; i < 10000; i++) {
      const cnpj = gerarCNPJ();
      expect(validarCNPJ(cnpj)).toBe(true);
    }
  });

  it("respeita o código de filial", () => {
    const cnpj = gerarCNPJ({ filial: "0042" });
    expect(cnpj.substring(8, 12)).toBe("0042");
  });

  it("formata corretamente quando solicitado", () => {
    const cnpj = gerarCNPJ({ formatado: true });
    expect(cnpj).toMatch(/^\d{2}\.\d{3}\.\d{3}\/\d{4}-\d{2}$/);
  });
});

Armadilhas comuns

Pesos trocados: invertendo os arrays de pesos gera um CNPJ que parece válido mas falha na validação real. Teste sempre com pelo menos 100 amostras.
Resto 10 ou 11 tratado como dígito: o dígito deve virar 0. Regra: se resto < 2, dígito é 0; senão, é 11 − resto.
Gerar sequências repetidas (00000000000000): passam no módulo 11 mas não são emitidos pela Receita. Adicione check de sequência única no próprio gerador.
Formatação hardcoded: use template string com slice, não regex com replace — é mais rápido e legível.
Salvar com formatação no banco: guarde apenas os 14 dígitos. Formatação é camada de apresentação.

Uso em ferramenta de dev

A função acima serve bem para automação de teste. Para uso manual (QA, demonstração, seed rápido), um gerador web interativo é mais prático. Você cola a quantidade e baixa em CSV — inclusive com filial parametrizada e suporte a grupos empresariais.

Vai mais fundo

Em teste de carga (load testing), gerar CNPJ a cada request é desperdício de CPU. Uma otimização comum é pré-gerar 1 milhão de CNPJs em um arquivo, carregar na memória e usar randomPickFromArray durante o teste. Reduz CPU do gerador em 95% sem perder realismo.

Comparação com outras abordagens

Métodos para obter CNPJs em teste
Critério	Vantagem	Desvantagem
Gerador local (este artigo)	Grátis, rápido, sem dependência	Requer escrever/copiar o código
API pública (4devs, geradornv)	Não requer código	Rate limit, dependência externa, sem SLA
Biblioteca (cpf-cnpj-validator)	Menos código para manter	Mais uma dependência
Copiar CNPJs reais da Receita	Realista	VIOLA LGPD — nunca faça

Boas práticas em teste e staging

Marque CNPJs de teste claramente: prefira campo is_test ou um range específico (ex.: começar com 99).
Nunca misture CNPJs real e teste no mesmo banco de prod: use ambiente separado.
Seed reproduzível: passe uma seed ao gerador para regeneráveis entre execuções.
Rotaciona periodicamente: em staging persistente, limpe CNPJs antigos para evitar colisão com novos.
Em demos públicas: use CNPJs começando com “00” ou outro prefixo fácil de identificar como fictício.

Gerador em uma frase

Gerar CNPJ em JavaScript é 20 linhas de código, roda em qualquer runtime, produz milhões de documentos por segundo e elimina a tentação (perigosa) de copiar CNPJ real em ambiente de desenvolvimento. Um dos investimentos de menor custo e maior ROI em segurança e qualidade de teste.

Perguntas frequentes

Por que precisamos gerar CNPJ em vez de usar um real?+

Três motivos. (1) Privacidade e LGPD: usar CNPJ real em testes ou demos expõe a empresa a vazamento de dado sensível. (2) Reprodutibilidade: você precisa controlar exatamente quais documentos aparecem em cada cenário de teste. (3) Volume: automação de testes exige milhares de CNPJs únicos — impossível obter licitamente. A geração local do algoritmo resolve os três sem depender de API externa.

Qual o algoritmo para gerar CNPJ?+

Gerar 12 dígitos (8 do número base + 4 do filial, sendo '0001' o padrão para matriz), calcular o primeiro dígito verificador via módulo 11 com pesos [5,4,3,2,9,8,7,6,5,4,3,2], calcular o segundo com pesos [6,5,4,3,2,9,8,7,6,5,4,3,2]. Em ambos, se o resultado for >= 10, o dígito é 0. O CNPJ final tem 14 dígitos: 8 base + 4 filial + 2 verificadores.

Por que não gerar usando random simples?+

Um CNPJ aleatório de 14 dígitos tem 10⁻² (1%) de chance de passar na validação de módulo 11. Se você precisa de 1000 CNPJs válidos, precisaria gerar 100.000 aleatórios e filtrar. Ineficiente. Calcular os dígitos verificadores diretamente a partir dos 12 primeiros dígitos é determinístico: cada chamada produz 1 CNPJ válido em O(1). Apenas alguns nanossegundos por documento.

O CNPJ gerado pode bater com um real?+

Tecnicamente sim, por coincidência. Existem ~99,9 bilhões de CNPJs matematicamente válidos; a Receita emitiu apenas algumas dezenas de milhões. A probabilidade de colisão é baixíssima (~0,00005%). Na prática, em desenvolvimento e testes, o risco é desprezível. Para produção, se o sistema persistir dados, marque claramente como teste (campo 'is_test=true') para evitar confusão futura.

Como gerar muitos CNPJs únicos sem repetir?+

Armazene os gerados em um Set, e em loop gere até Set ter o tamanho desejado. Em 10 milhões de CNPJs únicos, a probabilidade de colisão é matemática-mente irrelevante — você pode simplesmente chamar gerarCNPJ() em loop e confiar. Para volumes maiores, o Set protege. Em banco de dados de staging, a coluna UNIQUE no CNPJ detecta qualquer colisão na inserção.

Qual a diferença entre gerar CNPJ matriz e filial?+

A matriz tem os dígitos 9-12 iguais a '0001'. Filiais vão de '0002' até '9999'. Para simular realismo em teste de dados, você pode gerar o mesmo número base e variar o sufixo de filial. No código, basta parametrizar o filial: gerarCNPJ({ filial: '0001' }) vs gerarCNPJ({ filial: '0042' }). Ambos compartilham o número base mas têm dígitos verificadores diferentes.

Posso usar a mesma função no browser e no Node.js?+

Sim. O algoritmo usa apenas Math.random() e operações aritméticas básicas — disponíveis em qualquer runtime JavaScript (browser, Node, Deno, Bun, edge functions). Em TypeScript, uma única função serve cliente e servidor. Para testes automatizados, prefira Node + Jest/Vitest; para demos públicas, gere no browser sem exposição de chave. Em nenhum caso precisa de dependência externa.

O CNPJ alfanumérico (novo formato) já está disponível?+

A Receita anunciou o formato alfanumérico para emissões específicas a partir de 2026, mas em abril/2026 ainda é minoritário. Seu sistema deve aceitar e validar o formato se a integração exigir, mas para testes gerais, o CNPJ numérico de 14 dígitos continua sendo o padrão. Cheque a documentação oficial da Receita antes de ajustar o sistema em produção se CNPJ alfanumérico aparece como requisito.

#cnpj#javascript#typescript#algoritmo#gerador#módulo 11#node.js#testes#lgpd#brasil