Gerador de CPF válido online: como funciona e quando usar

O CPF segue uma estrutura matemática determinística. Qualquer ferramenta que entenda essa estrutura pode gerar documentos que passam em qualquer validador de formato, sem jamais tocar em dados reais de cidadãos brasileiros. Esse é o ponto de partida para entender o que um gerador de CPF faz e, principalmente, o que ele não faz.

O CPF tem estrutura matemática verificável

Anatomia dos 11 dígitos

O Cadastro de Pessoas Físicas é composto por 11 dígitos numéricos organizados como NNN.NNN.NNN-DD, onde:

• Posições 1-9: número de base, atribuído sequencialmente pela Receita Federal
• Posições 10-11: dígitos verificadores calculados a partir dos nove primeiros

A máscara visual (123.456.789-09) é apenas apresentação. O que importa ao validar é a sequência bruta de dígitos: 12345678909.

Cálculo dos dois dígitos verificadores (passo a passo com mod-11)

O algoritmo usa aritmética modular com base 11. Para o primeiro dígito verificador (posição 10):

1. Multiplique os 9 primeiros dígitos pelos pesos 10, 9, 8, 7, 6, 5, 4, 3, 2. 2. Some os produtos. 3. Calcule resto = soma % 11. 4. Se resto < 2, o primeiro dígito verificador é 0. Caso contrário, é 11 - resto.

Para o segundo dígito verificador (posição 11), repita o processo usando os 10 primeiros dígitos (incluindo o verificador recém-calculado) com pesos 11, 10, 9, 8, 7, 6, 5, 4, 3, 2.

Exemplo com o CPF 529.982.247-25:

• Base: 529982247
• Pesos primeiro dígito: 10→5, 9→2, 8→9, 7→9, 6→8, 5→2, 4→2, 3→4, 2→7
• Soma: 50+18+72+63+48+10+8+12+14 = 295
• 295 % 11 = 9 → primeiro dígito = 11 - 9 = 2 ✓
• Segundo verificador inclui o 2 calculado com peso 11: resultado 5 ✓

Por que um CPF aleatório quase nunca passa na validação

A probabilidade de 9 dígitos aleatórios produzirem verificadores corretos por acaso é de aproximadamente 1 em 100. Gerar números sem o cálculo dos verificadores resulta em rejeição imediata por qualquer biblioteca de validação, incluindo cpf-check (Node.js) e caelum-stella (Java).

Geradores de CPF calculam os verificadores, não inventam números

Diferença entre "CPF válido por formato" e "CPF existente na Receita"

Um CPF gerado por software é matematicamente válido, mas não pertence a nenhuma pessoa. A Receita Federal não expõe endpoint público para verificar se um CPF está ativo na base. Ferramentas de consulta de situação cadastral (SERPRO, eCPF) requerem autenticação e retornam dados pessoais reais. Um gerador de CPF não faz consulta à Receita. O dado gerado é fictício e descartável.

Casos excluídos pelo algoritmo (111.111.111-11 e similares)

O algoritmo mod-11 exclui sequências onde todos os 9 dígitos de base são iguais. Esses números são tecnicamente inválidos porque os pesos produzem dígitos verificadores inconsistentes. Um gerador correto descarta essas sequências antes de calcular os verificadores.

Como a semente aleatória garante distribuição uniforme

Bons geradores sorteiam os 9 dígitos de base via Math.random() ou equivalente criptograficamente seguro, verificam se a sequência é de dígitos repetidos e, se não for, aplicam o cálculo dos verificadores. O resultado cobre aproximadamente 900 milhões de combinações válidas com distribuição razoavelmente uniforme.

Quando usar CPF fictício em testes é correto e legal

Ambientes de desenvolvimento e staging (caso de uso central)

Qualquer sistema que processe CPF precisa testar fluxos de cadastro, validação de entrada, persistência e consulta. Usar dados fictícios nesses ambientes é a prática correta. O dado nunca existiu, não pertence a ninguém e não pode ser vinculado a uma pessoa natural, o que o exclui da definição de dado pessoal conforme a LGPD Art. 5º, I.

Dados de seed em migrations e fixtures

Seed scripts criam estados iniciais para bancos de dados em desenvolvimento. Usar CPFs fictícios nesses scripts é idiomático e elimina dependência de dados reais para configurar o ambiente. Veja como integrar com Prisma na seção sobre a API REST abaixo.

Testes automatizados e pipelines de CI

Testes de integração que cobrem validação de CPF, fluxos de onboarding ou regras de negócio dependentes do documento precisam de entradas controladas. CPFs fictícios garantem determinismo: o mesmo valor de entrada sempre produz o mesmo comportamento esperado, sem risco de o dado "expirar" ou mudar de situação cadastral.

Demos, screenshots e materiais de treinamento

Manuais de sistema, apresentações internas e materiais de treinamento frequentemente precisam exibir documentos em telas. Usar um CPF fictício elimina o risco de exposição acidental de dados reais em capturas de tela ou gravações.

Quando usar CPF fictício viola a LGPD

LGPD Art. 7º, IX e o princípio da necessidade

O Art. 7º, IX da LGPD autoriza tratamento de dados pessoais quando necessário para atender interesses legítimos do controlador, desde que não prevaleçam direitos do titular. O princípio da necessidade (Art. 6º, III) exige que apenas os dados estritamente necessários sejam processados. Usar CPF real onde um fictício resolveria viola diretamente esse princípio.

O erro de copiar CPFs reais de produção para dev

Copiar dumps de produção para ambientes de desenvolvimento é uma das violações mais comuns e mais silenciosas. O ambiente de dev geralmente tem controles menores: logs mais verbosos, acesso mais amplo, menos monitoramento. Um CPF real nesse ambiente representa tratamento sem finalidade legítima para os dados do titular.

AVISO: A ANPD já notificou empresas por compartilhamento indevido de bases de dados entre ambientes. A multa administrativa pode chegar a 2% do faturamento nacional, limitado a R$ 50 milhões por infração (LGPD Art. 52). Substitua dados reais por dados fictícios antes de qualquer cópia para dev ou staging.

Pseudonimização não é anonimização: o que o Art. 13 da LGPD diz

O Art. 13 da LGPD define pseudonimização como tratamento pelo qual o dado perde a possibilidade de associação ao titular sem uso de informação adicional mantida separadamente. Mascarar um CPF real (ex: *.456.789-) não é anonimização: a sequência central ainda permite reidentificação combinada com outros campos. Dados gerados por algoritmo, sem base em registros reais, não têm esse problema.

Checklist antes de subir qualquer base de testes

• [ ] Nenhum CPF no dump pertence a um usuário real
• [ ] Nenhum nome, email ou telefone é dado pessoal real
• [ ] O ambiente de destino tem controles de acesso equivalentes ao de produção, ou os dados foram substituídos por fictícios
• [ ] O seed script usa CPFs gerados, não copiados

O algoritmo mod-11 implementado em TypeScript

Função generateCPF() do zero

function generateCPF(): string {
  const digits = Array.from({ length: 9 }, () => Math.floor(Math.random() * 10));

  if (digits.every((d) => d === digits[0])) return generateCPF();

  const calcVerifier = (base: number[], weight: number): number => {
    const sum = base.reduce((acc, d, i) => acc + d * (weight - i), 0);
    const remainder = sum % 11;
    return remainder < 2 ? 0 : 11 - remainder;
  };

  const d1 = calcVerifier(digits, 10);
  const d2 = calcVerifier([...digits, d1], 11);

  return [...digits, d1, d2].join('');
}

Função validateCPF() cobrindo os edge cases

function validateCPF(raw: string): boolean {
  const cpf = raw.replace(/\D/g, '');

  if (cpf.length !== 11) return false;
  if (/^(\d)\1{10}$/.test(cpf)) return false;

  const digits = cpf.split('').map(Number);

  const calcVerifier = (base: number[], weight: number): number => {
    const sum = base.reduce((acc, d, i) => acc + d * (weight - i), 0);
    const remainder = sum % 11;
    return remainder < 2 ? 0 : 11 - remainder;
  };

  const d1 = calcVerifier(digits.slice(0, 9), 10);
  const d2 = calcVerifier(digits.slice(0, 10), 11);

  return d1 === digits[9] && d2 === digits[10];
}

Teste unitário mínimo para os dois

import { describe, it, expect } from 'vitest';

describe('CPF', () => {
  it('gera CPF com 11 dígitos numéricos', () => {
    const cpf = generateCPF();
    expect(cpf).toHaveLength(11);
    expect(/^\d{11}$/.test(cpf)).toBe(true);
  });

  it('CPF gerado passa na validação em 100 amostras', () => {
    for (let i = 0; i < 100; i++) {
      expect(validateCPF(generateCPF())).toBe(true);
    }
  });

  it('rejeita sequências repetidas', () => {
    expect(validateCPF('11111111111')).toBe(false);
    expect(validateCPF('00000000000')).toBe(false);
  });

  it('rejeita CPF com tamanho errado', () => {
    expect(validateCPF('1234567890')).toBe(false);
    expect(validateCPF('123456789012')).toBe(false);
  });

  it('aceita CPF com máscara', () => {
    expect(validateCPF('529.982.247-25')).toBe(true);
  });

  it('rejeita CPF com verificador errado', () => {
    expect(validateCPF('529.982.247-26')).toBe(false);
  });
});

Gerar CPF pela API REST sem código de validação próprio

Chamada GET simples com type=cpf&quantity=10

curl "https://fakeforge.com.br/api/generate?type=cpf&quantity=10&format=json"

A resposta inclui o campo _meta com atribuição da fonte, seguido dos dados:

{
  "_meta": {
    "source": "FakeForge BR",
    "url": "https://fakeforge.com.br",
    "generated_at": "2026-06-04T10:00:00Z",
    "license": "CC0"
  },
  "type": "cpf",
  "quantity": 10,
  "data": ["52998224725", "01234567890"]
}

Exportar lista em JSON, CSV e SQL para fixtures

Troque format=json por format=csv ou format=sql. O formato SQL retorna um bloco CREATE TABLE com INSERT INTO pronto para colar em migrations. Os parâmetros completos estão em /docs.

Integrar com seed scripts do Prisma ou TypeORM

import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

async function seed() {
  const response = await fetch(
    'https://fakeforge.com.br/api/generate?type=cpf&quantity=20&format=json'
  );
  const { data: cpfs } = await response.json();

  await prisma.user.createMany({
    data: cpfs.map((cpf: string, i: number) => ({
      cpf,
      name: `Usuário Teste ${i + 1}`,
      email: `teste${i + 1}@example.com`,
    })),
    skipDuplicates: true,
  });

  await prisma.$disconnect();
}

seed();

DICA: Para gerar CPF junto com nome, endereço e contato correlacionados, onde o DDD do telefone bate com o estado do CEP, use type=pessoa. Veja /gerador-pessoa.

Ferramentas online: o que avaliar antes de usar

HTTPS e ausência de log server-side

Qualquer ferramenta que gere dados via formulário web deve operar sobre HTTPS. Mesmo sendo dados fictícios, o contexto de uso pode ser sensível. Prefira ferramentas que declarem explicitamente não registrar inputs do usuário.

Geração client-side vs server-side (implicação de privacidade)

Ferramentas que executam a geração inteiramente no navegador (JavaScript puro, sem chamada ao servidor) não enviam nada para infraestrutura externa. Ferramentas que chamam uma API server-side registram ao menos IP e timestamp nos logs do servidor. Para ambientes com políticas de segurança restritivas, isso é um critério relevante.

Suporte a bulk e formatos de exportação

Gerar um CPF por vez é ineficiente para seed scripts. Avalie se a ferramenta suporta geração em lote, exportação em CSV e SQL, e se existe API programática. O /gerador-cpf gera até 10.000 itens por chamada com exportação nos três formatos.

Validador de CPF: diferente do gerador, mesmo algoritmo

Quando você precisa validar, não gerar

Formulários de cadastro, integrações com sistemas legados e ETLs que recebem CPF como entrada precisam de validação, não de geração. O algoritmo é o mesmo mod-11, aplicado no sentido inverso: receber os 11 dígitos e confirmar se os verificadores batem. Use /validar-cpf para verificar CPFs individualmente sem implementar o algoritmo.

Como testar o validador com CPFs intencionalmente inválidos

Um validador robusto deve rejeitar:

• CPFs com menos ou mais de 11 dígitos
• Sequências com todos os dígitos iguais (111.111.111-11)
• CPFs com verificadores incorretos (529.982.247-26 em vez de -25)
• Strings não numéricas após remoção de máscara

Use os casos acima como suite mínima de testes de regressão para qualquer implementação de validação de CPF.

Erros comuns ao trabalhar com CPF em código

Comparar string com máscara vs sem máscara

"529.982.247-25" === "52998224725" retorna false. Normalize sempre antes de comparar: remova pontos, hífen e espaços via replace(/\D/g, ''). Armazene CPF sem máscara no banco. Aplique a máscara apenas na camada de apresentação.

Aceitar CPF com todos os dígitos iguais como válido

O regex /^(\d)\1{10}$/ captura qualquer sequência de 11 dígitos repetidos. Esse teste deve vir antes do cálculo dos verificadores, porque sequências como 111.111.111-11 satisfazem o mod-11 de forma espúria em algumas implementações incompletas.

Não remover pontuação antes de validar

Usuários digitam CPF com e sem máscara. Sistemas legados entregam CPF em formatos variados. A primeira linha de qualquer função validateCPF deve ser const cpf = raw.replace(/\D/g, ''). Qualquer validação feita antes dessa normalização vai gerar falsos negativos para entradas válidas com formatação diferente.

Resumo

• O CPF é matematicamente verificável via mod-11: qualquer gerador correto calcula os dígitos verificadores com base nos 9 primeiros dígitos, não os sorteia aleatoriamente.
• Dado gerado por algoritmo não é dado pessoal (LGPD Art. 5º, I) e pode ser usado livremente em dev, staging, CI e fixtures, sem necessidade de bases legais adicionais.
• Copiar CPFs reais de produção para ambientes de desenvolvimento viola o princípio da necessidade da LGPD (Art. 6º, III) e expõe a empresa a sanções administrativas de até R$ 50 milhões por infração (Art. 52).
• Pseudonimização parcial (mascaramento) não elimina o risco de reidentificação. Dados gerados por algoritmo, sem origem em registros reais, são a alternativa correta.
• Para gerar CPF no navegador, use /gerador-cpf. Para validar um CPF existente, use /validar-cpf. Para integrar via API REST com suporte a JSON, CSV e SQL, consulte /docs.
• Para gerar CPF junto com nome, endereço, telefone e email correlacionados em uma única chamada, use /gerador-pessoa.