# 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.

- Endereço oficial: https://pradev.com.br/guias/como-gerar-cpf-e-cnpj-para-testes
- Tipo: Guia
- Publicado em: 2026-09-30
- Atualizado em: 2026-09-30
- Autor: Leonardo Gaertner (https://pradev.com.br/sobre)
- Ferramentas: [Gerador de CPF](https://pradev.com.br/gerador-de-cpf), [Gerador de CNPJ](https://pradev.com.br/gerador-de-cnpj)

## 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](https://pradev.com.br/guias/como-validar-cpf-em-javascript) detalha a conta.

Para gerar alguns números na hora, sem código, use o [gerador de CPF](https://pradev.com.br/gerador-de-cpf) ou o [gerador de CNPJ](https://pradev.com.br/gerador-de-cnpj). Para uma pessoa fictícia completa, com nome, CPF, celular e endereço, use o [gerador de pessoas](https://pradev.com.br/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)}`;
}
```

_JavaScript_

```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:]}"
```

_Python_

```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);
}
```

_PHP_

## 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](https://pradev.com.br/guias/cnpj-alfanumerico-como-validar).

```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)}`;
}
```

_JavaScript. 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](https://pradev.com.br/guias/como-gerar-senha-segura-em-codigo).

## 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

- [Receita Federal: perguntas e respostas sobre o CNPJ alfanumérico](https://www.gov.br/receitafederal/pt-br/centrais-de-conteudo/publicacoes/perguntas-e-respostas/cnpj/cnpj-alfanumerico.pdf)

## Guias relacionados

- [Como validar CPF em JavaScript, Python e PHP](https://pradev.com.br/guias/como-validar-cpf-em-javascript): Aprenda a calcular os dígitos verificadores do CPF e veja funções prontas e testadas para validar CPF em JavaScript, Python e PHP.
- [CNPJ alfanumérico: o que muda e como validar em código](https://pradev.com.br/guias/cnpj-alfanumerico-como-validar): Entenda o CNPJ alfanumérico (letras e números), o que muda para quem desenvolve e veja funções testadas para validar em JavaScript, Python e PHP.