Como gerar CPF e CNPJ válidos para testes em código

Um CPF ou CNPJ de teste precisa passar na validação dos dígitos verificadores, mas não deve pertencer a ninguém. Este guia mostra como gerar CPF e CNPJ matematicamente válidos em JavaScript, Python e PHP, explica por que sequências como 111.111.111-11 precisam ser descartadas e como deixar os testes reproduzíveis.

Por Leonardo Gaertner · Publicado em

Como um CPF válido é montado

O CPF tem 9 dígitos de base e 2 dígitos verificadores. Para gerar um, sorteie os 9 primeiros e calcule os outros 2 com a mesma conta usada na validação: pesos de 10 a 2 para o primeiro dígito e de 11 a 2 para o segundo, resto da divisão por 11, e zero quando o resto for menor que 2. O guia de validação de CPF detalha a conta.

Para gerar alguns números na hora, sem código, use o gerador de CPF ou o gerador de CNPJ. Para uma pessoa fictícia completa, com nome, CPF, celular e endereço, use o gerador de pessoas.

Por que descartar as sequências repetidas

Se os 9 primeiros dígitos forem todos iguais, a conta gera dígitos verificadores iguais a eles: 111.111.111-11 passa no cálculo. Mas a Receita não emite esses números, e os validadores costumam recusá-los. Um gerador que não os descarta cria dados de teste que o próprio sistema rejeita, de vez em quando, e o teste falha sem motivo aparente.

Gerar CPF

As três versões devolvem o CPF já formatado. Para só os dígitos, remova a máscara no fim.

JavaScript 
// Gera um CPF matematicamente válido, só para testes
function gerarCPF() {
  const n = Array.from({ length: 9 }, () => Math.floor(Math.random() * 10));
  // 000.000.000-00, 111.111.111-11 e parecidos passam no cálculo, mas são recusados
  if (n.every((d) => d === n[0])) return gerarCPF();

  const digito = (base) => {
    const soma = base.reduce((s, d, i) => s + d * (base.length + 1 - i), 0);
    const resto = soma % 11;
    return resto < 2 ? 0 : 11 - resto;
  };
  n.push(digito(n));
  n.push(digito(n));
  const s = n.join('');
  return `${s.slice(0, 3)}.${s.slice(3, 6)}.${s.slice(6, 9)}-${s.slice(9)}`;
}
Python 
import random


def gerar_cpf() -> str:
    """Gera um CPF matematicamente válido, só para testes."""
    n = [random.randint(0, 9) for _ in range(9)]
    if len(set(n)) == 1:  # sequências repetidas são recusadas pelos validadores
        return gerar_cpf()

    def digito(base: list[int]) -> int:
        soma = sum(d * (len(base) + 1 - i) for i, d in enumerate(base))
        resto = soma % 11
        return 0 if resto < 2 else 11 - resto

    n.append(digito(n))
    n.append(digito(n))
    s = "".join(map(str, n))
    return f"{s[:3]}.{s[3:6]}.{s[6:9]}-{s[9:]}"
PHP 
<?php
// Gera um CPF matematicamente válido, só para testes
function gerarCpf(): string
{
    do {
        $n = array_map(fn() => random_int(0, 9), range(1, 9));
    } while (count(array_unique($n)) === 1); // sequências repetidas são recusadas

    $digito = function (array $base): int {
        $soma = 0;
        foreach ($base as $i => $d) {
            $soma += $d * (count($base) + 1 - $i);
        }
        $resto = $soma % 11;
        return $resto < 2 ? 0 : 11 - $resto;
    };
    $n[] = $digito($n);
    $n[] = $digito($n);
    return vsprintf('%d%d%d.%d%d%d.%d%d%d-%d%d', $n);
}

Gerar CNPJ

O CNPJ tem 8 dígitos da empresa, 4 da filial (0001 é a matriz) e 2 verificadores, com pesos de 2 a 9 da direita para a esquerda. Desde julho de 2026 também existem CNPJs com letras, e o cálculo muda: veja o guia do CNPJ alfanumérico.

JavaScript 
// Gera um CNPJ numérico matematicamente válido, só para testes.
// A filial fica fixa em 0001 (matriz), como na maioria dos CNPJs reais.
function gerarCNPJ() {
  const n = [...Array.from({ length: 8 }, () => Math.floor(Math.random() * 10)), 0, 0, 0, 1];

  const digito = (base) => {
    // Pesos de 2 a 9, da direita para a esquerda, recomeçando em 2
    const soma = base.reduceRight((s, d, i) => s + d * (((base.length - 1 - i) % 8) + 2), 0);
    const resto = soma % 11;
    return resto < 2 ? 0 : 11 - resto;
  };
  n.push(digito(n));
  n.push(digito(n));
  const s = n.join('');
  return `${s.slice(0, 2)}.${s.slice(2, 5)}.${s.slice(5, 8)}/${s.slice(8, 12)}-${s.slice(12)}`;
}

Gera o formato numérico, com filial 0001.

Cuidados

  • Um número gerado pode coincidir com o de uma pessoa ou empresa real. Use só em ambiente de teste, nunca para cadastros, compras ou qualquer tentativa de se passar por alguém.
  • Nunca copie CPFs reais da produção para o ambiente de teste. Além do risco, isso esbarra na LGPD.
  • Para testes reproduzíveis, fixe a semente do sorteio (random.seed(42) no Python) ou gere a lista uma vez e salve como dado fixo do teste.
  • Aqui Math.random e random bastam, porque não há segredo. Para senhas e tokens, use um gerador criptográfico: veja como gerar senha segura.

Achou um erro neste guia? Avise por e-mail.

Ferramentas para usar junto

Perguntas frequentes

Posso usar um CPF gerado em um cadastro real?

Não. O número só é válido na conta dos dígitos e pode pertencer a outra pessoa. Usar CPF de terceiros ou inventado em cadastros reais pode configurar crime. Use apenas em testes de software.

Como gerar CPF em Python?

Sorteie 9 dígitos, descarte o caso em que todos são iguais e calcule os dois dígitos verificadores com pesos de 10 a 2 e de 11 a 2. A função deste guia faz isso e devolve o CPF formatado.

Por que meu teste falha de vez em quando com um CPF gerado?

O gerador provavelmente não descarta sequências repetidas, como 000.000.000-00, que passam no cálculo mas são recusadas pelo validador. Descarte esse caso ou fixe a semente para o teste ser reproduzível.

O CNPJ gerado precisa ter filial 0001?

Não precisa, mas 0001 indica a matriz e é o caso mais comum. Qualquer número de filial funciona na conta, desde que os dígitos verificadores sejam calculados sobre ele.

Fontes

Outros guias