CPF Aleatório: Como Gerar, Validar e Usar com Segurança em 2026

Diferença Entre CPF Aleatório e CPF com Estado Específico

Existem basicamente duas formas de gerar CPF: aleatória e regional. Vamos entender as diferenças práticas entre elas.

CPF Aleatório: Quando você gera um CPF aleatório, o nono dígito (que indica a região fiscal) também é escolhido aleatoriamente. Isso significa que em um lote de 100 CPFs aleatórios, você terá uma mistura natural de todos os estados brasileiros.

Por exemplo, gerando 10 CPFs aleatórios, você pode ter:

• 3 CPFs de São Paulo (dígito 8)
• 2 CPFs do Rio Grande do Sul (dígito 0)
• 1 CPF de Minas Gerais (dígito 6)
• 2 CPFs do Ceará (dígito 3)
• 2 CPFs do Paraná (dígito 9)

A distribuição não segue nenhuma lógica. É simplesmente aleatória.

CPF com Estado Específico: Quando você escolhe gerar CPF de um estado específico, o sistema força o nono dígito a ser sempre o mesmo. Por exemplo, se você escolher “São Paulo”, todos os CPFs gerados terão o dígito 8 na nona posição.

Gerando 10 CPFs de São Paulo, todos terão este padrão:

• XXX.XXX.XX8-XX

Isso é útil quando você está testando funcionalidades regionais específicas ou precisa simular uma base de usuários de um estado particular.

Quando Escolher Cada Tipo

Escolha CPF aleatório quando:

• Você precisa de dados diversos para testes abrangentes
• Está populando um banco de dados de demonstração
• Quer simular uma base nacional de usuários
• Precisa testar comportamento com CPFs de várias regiões
• Quer máxima cobertura de teste

Escolha CPF de estado específico quando:

• Está testando funcionalidades regionais
• Precisa simular uma filial ou loja de um estado
• Tem regras de negócio específicas por região
• Quer dados mais previsíveis e organizados
• Está criando relatórios regionais simulados

Nossa ferramenta permite gerar ambos os tipos. Basta escolher “Todos os Estados” para CPFs aleatórios ou selecionar um estado específico para CPFs regionais. Experimente agora em nosso <a href=”https://geradordecpfonline.com/gerador-de-cpf/”>Gerador de CPF Online</a>.

Quando Usar CPF Aleatório vs CPF Regional

A escolha entre CPF aleatório e CPF regional pode impactar significativamente a qualidade dos seus testes e a representatividade dos seus dados. Vamos ver cenários práticos para cada abordagem.

Cenário 1: Testes de Sistema E-commerce Nacional

Imagine que você está desenvolvendo uma loja online que atende todo o Brasil. Se você testar apenas com CPFs de São Paulo, pode não descobrir que há um bug no cálculo de frete para o Acre, ou que o sistema rejeita CPFs de Roraima por algum motivo.

Usando CPFs aleatórios, você automaticamente testa com todas as regiões fiscais possíveis. Em 1000 CPFs aleatórios, você terá naturalmente uma representação de todos os estados, garantindo que o sistema funciona para qualquer brasileiro, independente da origem.

Cenário 2: Populate de Banco de Dados para Demo

Você vai apresentar seu sistema para um investidor. Um banco de dados com 10.000 clientes fictícios precisa parecer real. Se todos os CPFs tiverem o mesmo padrão regional, fica óbvio que são dados fake.
CPFs aleatórios criam uma base de dados convincente. O investidor vê São Paulo, Rio, Bahia, Amazonas – uma distribuição natural que transmite profissionalismo.

Cenário 3: Testes Automatizados com Alta Cobertura

Em testes automatizados que rodam centenas de vezes por dia, usar sempre os mesmos CPFs reduz a cobertura. Bugs raros, que acontecem apenas com certas combinações de dígitos, podem passar despercebidos.
CPFs aleatórios aumentam a probabilidade de encontrar esses bugs escondidos. Cada execução usa números diferentes, explorando um espaço maior de possibilidades.

Cenário 4: Simulação de Crescimento Orgânico

Quando você está testando um dashboard de analytics ou relatórios gerenciais, CPFs aleatórios simulam melhor o crescimento orgânico de usuários que vêm de diferentes regiões.
Você pode criar dados históricos onde, ao longo do tempo, a base de clientes se diversifica geograficamente, exatamente como aconteceria no mundo real.

Casos Onde CPF Regional é Melhor

Por outro lado, há situações onde CPFs regionais fazem mais sentido:

• Testes de Filiais Regionais: Se você está testando o sistema de uma filial específica em Curitiba, faz sentido usar apenas CPFs do Paraná (dígito 9).
• Validação de Regras de Negócio: Algumas empresas têm promoções ou regras específicas por estado. Testar isso requer CPFs do estado em questão.
• Relatórios Estaduais: Ao testar relatórios que agregam dados por UF, usar CPFs de um estado facilita a validação dos totais.
• Treinamento de Equipe: Ao treinar atendentes de uma região, usar CPFs locais torna os exemplos mais familiares e relevantes.

A regra geral é simples: use CPF aleatório para amplitude e diversidade, use CPF regional para foco e especificidade.

Como Gerar CPF Aleatório Online

Gerar CPF aleatório online é extremamente simples com as ferramentas certas. Vou te mostrar o processo completo, passo a passo.

Método 1: Usando Nossa Ferramenta

A forma mais rápida é usar nosso gerador gratuito:

Passo 1: Acesse o Gerador de CPF Online

Passo 2: No campo “Selecione o Estado”, escolha “Todos os Estados”. Essa é a opção que gera CPFs completamente aleatórios, sem preferência regional.

Passo 3: Defina quantos CPFs você precisa. Pode ser 1, 10, 100 ou até 1000. Para testes básicos, 10-20 CPFs costumam ser suficientes. Para popular bancos de dados, você pode precisar de centenas ou milhares.

Passo 4: Escolha o formato:

• Com máscara: 123.456.789-09 (mais legível, melhor para interfaces)
• Somente números: 12345678909 (melhor para bancos de dados e código)

Passo 5: Clique em “Gerar CPFs”. Os números aparecem instantaneamente na tela.

Passo 6: Use os botões para:

• Copiar: Copia todos os CPFs para a área de transferência
• Exportar CSV: Baixa um arquivo CSV com todos os CPFs, perfeito para importar em planilhas ou bancos de dados

A ferramenta automaticamente garante que:

• Todos os CPFs são matematicamente válidos
• Não há duplicatas na lista gerada
• Os números são verdadeiramente aleatórios (não sequenciais)
• Nenhum CPF com todos os dígitos iguais (como 111.111.111-11)

Vantagens da Geração Online

• Velocidade: Gerar 1000 CPFs aleatórios leva menos de 1 segundo. É instantâneo.
• Sem instalação: Funciona direto no navegador. Não precisa instalar nada, baixar programas ou configurar bibliotecas.
• Qualidade garantida: A ferramenta implementa o algoritmo oficial da Receita Federal. Você tem certeza que todos os números passarão em qualquer validação.
• Exportação fácil: O botão de CSV permite baixar os dados prontos para usar. Você pode abrir no Excel, importar em um banco de dados ou usar em scripts.
• Mobile-friendly: Funciona perfeitamente em celulares e tablets. Você pode gerar CPFs de qualquer lugar.

Dicas de Uso Eficiente

Se você precisa de CPFs regularmente, considere estas práticas:

• Gere em lotes maiores: Em vez de gerar 10 CPFs toda vez que precisa, gere 100 de uma vez e salve o CSV. Você terá uma reserva pronta.
• Mantenha um arquivo de teste: Crie um arquivo “cpfs-teste.csv” com alguns milhares de CPFs aleatórios. Use esse arquivo como fonte de dados para todos os seus projetos.
• Use a validação: Nossa ferramenta também tem um validador integrado. Se você receber um CPF de algum lugar e quiser confirmar se está correto, use o validador antes de usar.
• Combine com outros dados: Para testes mais realistas, combine os CPFs gerados com nomes fictícios e endereços. Isso cria perfis de teste completos.

Para quem precisa validar CPFs gerados ou recebidos, temos um guia completo sobre <a href=”https://geradordecpfonline.com/como-validar-cpf-online/”>como validar CPF online</a>

Vantagens da Geração Aleatória em Massa

Gerar CPFs aleatórios em grandes quantidades traz benefícios específicos que vão além da simples geração unitária. Vamos explorar por que a geração em massa é tão valiosa.

1. População Rápida de Bancos de Dados

Quando você está configurando um ambiente de desenvolvimento ou teste, precisa de dados realistas. Manualmente criar milhares de registros seria impraticável.

Com geração em massa de CPFs aleatórios, você pode:

• Popular uma tabela de clientes com 10.000 registros em segundos
• Criar histórico de vendas com compradores diversos
• Simular crescimento de base de usuários ao longo do tempo
• Testar performance do banco com volumes realistas

Exemplo prático: você precisa testar se o banco de dados aguenta 1 milhão de clientes. Gerar 1 milhão de CPFs aleatórios, exportar em CSV e fazer um bulk insert resolve isso em minutos.

2. Testes de Carga e Performance

Para testar se seu sistema aguenta alta demanda, você precisa simular muitos usuários simultâneos. Cada usuário precisa de um CPF.

CPFs aleatórios em massa permitem:

• Criar milhares de contas de teste simultaneamente
• Simular picos de acesso sem repetir CPFs
• Testar concorrência e race conditions
• Validar limites de processamento do sistema

Se você usar sempre os mesmos 10 CPFs, não está realmente testando carga. Com 100.000 CPFs aleatórios únicos, você simula um cenário real de crescimento explosivo.

3. Maior Cobertura de Testes Automatizados

Testes automatizados que rodam milhares de vezes se beneficiam de dados variados. Quanto mais CPFs diferentes você usar, maior a chance de encontrar bugs raros.

Pense assim: um bug que só acontece quando o terceiro dígito do CPF é 7 e o nono é 2 tem apenas 1% de chance de aparecer. Se você usa 10 CPFs fixos que não têm essa combinação, nunca encontrará o bug. Com 10.000 CPFs aleatórios, estatisticamente você testará essa combinação cerca de 100 vezes.

4. Redução de Falsos Positivos

Usar sempre os mesmos CPFs pode criar falsos positivos nos testes. O sistema pode funcionar perfeitamente para aqueles 10 números específicos, mas falhar para outros.

CPFs aleatórios em massa eliminam essa armadilha. Se o teste passa com 1000 CPFs completamente diferentes, você tem muito mais confiança de que o código está correto.

5. Dados Realistas para Demonstrações

Em apresentações e demos, dados falsos óbvios prejudicam a credibilidade. Uma lista de clientes todos com CPFs de São Paulo ou com números sequenciais grita “isso é fake”.

Uma base com milhares de CPFs aleatórios parece real:

• Distribuição geográfica natural
• Números sem padrão aparente
• Variedade que imita a realidade

Investidores, stakeholders e clientes ficam mais impressionados quando os dados parecem autênticos.

Se você trabalha com grandes volumes de dados, também vale conferir nossa <a href=”https://geradordecpfonline.com/lista-de-cpfs-validos/”>lista de CPFs válidos para testes</a> que explica as melhores práticas de uso em massa.

Como Gerar CPF Aleatório em Código

Para desenvolvedores que precisam integrar geração de CPF aleatório diretamente no código, vou mostrar implementações práticas em diferentes linguagens.

function gerarCPFAleatorio() {
    // Gera 9 dígitos aleatórios
    let cpf = '';
    for (let i = 0; i < 9; i++) {
        cpf += Math.floor(Math.random() * 10);
    }
    
    // Calcula primeiro dígito verificador
    let soma = 0;
    for (let i = 0; i < 9; i++) {
        soma += parseInt(cpf.charAt(i)) * (10 - i);
    }
    let resto = soma % 11;
    let digito1 = resto < 2 ? 0 : 11 - resto;
    cpf += digito1;
    
    // Calcula segundo dígito verificador
    soma = 0;
    for (let i = 0; i < 10; i++) {
        soma += parseInt(cpf.charAt(i)) * (11 - i);
    }
    resto = soma % 11;
    let digito2 = resto < 2 ? 0 : 11 - resto;
    cpf += digito2;
    
    return cpf;
}

// Formatar CPF com máscara
function formatarCPF(cpf) {
    return cpf.replace(/(d{3})(d{3})(d{3})(d{2})/, '$1.$2.$3-$4');
}

// Gerar múltiplos CPFs aleatórios únicos
function gerarMultiplosCPFs(quantidade) {
    const cpfs = new Set(); // Garante unicidade
    
    while (cpfs.size < quantidade) {
        cpfs.add(gerarCPFAleatorio());
    }
    
    return Array.from(cpfs);
}

// Exemplos de uso
console.log(gerarCPFAleatorio());                    // "12345678909"
console.log(formatarCPF(gerarCPFAleatorio()));      // "123.456.789-09"
console.log(gerarMultiplosCPFs(10));                // Array com 10 CPFs únicos

import random

def gerar_cpf_aleatorio():
    """
    Gera um CPF completamente aleatório e válido
    
    Returns:
        str: CPF sem formatação (11 dígitos)
    """
    # Gera 9 dígitos aleatórios
    cpf = [random.randint(0, 9) for _ in range(9)]
    
    # Calcula primeiro dígito verificador
    soma = sum(cpf[i] * (10 - i) for i in range(9))
    resto = soma % 11
    digito1 = 0 if resto < 2 else 11 - resto
    cpf.append(digito1)
    
    # Calcula segundo dígito verificador
    soma = sum(cpf[i] * (11 - i) for i in range(10))
    resto = soma % 11
    digito2 = 0 if resto < 2 else 11 - resto
    cpf.append(digito2)
    
    return ''.join(map(str, cpf))

def formatar_cpf(cpf):
    """Formata CPF com máscara XXX.XXX.XXX-XX"""
    return f"{cpf[:3]}.{cpf[3:6]}.{cpf[6:9]}-{cpf[9:]}"

def gerar_multiplos_cpfs(quantidade):
    """
    Gera múltiplos CPFs únicos
    
    Args:
        quantidade (int): Número de CPFs a gerar
        
    Returns:
        set: Conjunto de CPFs únicos
    """
    cpfs = set()
    while len(cpfs) < quantidade:
        cpfs.add(gerar_cpf_aleatorio())
    return cpfs

# Exemplos de uso
print(gerar_cpf_aleatorio())                    # "12345678909"
print(formatar_cpf(gerar_cpf_aleatorio()))     # "123.456.789-09"

# Gerar 100 CPFs e salvar em arquivo
cpfs = gerar_multiplos_cpfs(100)
with open('cpfs_aleatorios.txt', 'w') as f:
    for cpf in cpfs:
        f.write(f"{formatar_cpf(cpf)}n")

<?php

function gerarCPFAleatorio() {
    // Gera 9 dígitos aleatórios
    $cpf = '';
    for ($i = 0; $i < 9; $i++) {
        $cpf .= rand(0, 9);
    }
    
    // Calcula primeiro dígito verificador
    $soma = 0;
    for ($i = 0; $i < 9; $i++) {
        $soma += $cpf[$i] * (10 - $i);
    }
    $resto = $soma % 11;
    $digito1 = $resto < 2 ? 0 : 11 - $resto;
    $cpf .= $digito1;
    
    // Calcula segundo dígito verificador
    $soma = 0;
    for ($i = 0; $i < 10; $i++) {
        $soma += $cpf[$i] * (11 - $i);
    }
    $resto = $soma % 11;
    $digito2 = $resto < 2 ? 0 : 11 - $resto;
    $cpf .= $digito2;
    
    return $cpf;
}

function formatarCPF($cpf) {
    return substr($cpf, 0, 3) . '.' . 
           substr($cpf, 3, 3) . '.' . 
           substr($cpf, 6, 3) . '-' . 
           substr($cpf, 9, 2);
}

function gerarMultiplosCPFs($quantidade) {
    $cpfs = [];
    while (count($cpfs) < $quantidade) {
        $cpf = gerarCPFAleatorio();
        if (!in_array($cpf, $cpfs)) {
            $cpfs[] = $cpf;
        }
    }
    return $cpfs;
}

// Exemplos de uso
echo gerarCPFAleatorio() . "n";           // 12345678909
echo formatarCPF(gerarCPFAleatorio()) . "n";  // 123.456.789-09

// Gerar 50 CPFs
$cpfs = gerarMultiplosCPFs(50);
foreach ($cpfs as $cpf) {
    echo formatarCPF($cpf) . "n";
}

?>

Esses códigos são prontos para usar em produção. Todos implementam o algoritmo oficial Módulo 11 e garantem CPFs matematicamente válidos.

Casos de Uso Práticos de CPF Aleatório

Vamos ver aplicações reais de CPF aleatório em diferentes contextos profissionais.

Caso 1: E-commerce em Desenvolvimento

Uma startup está desenvolvendo uma plataforma de e-commerce. A equipe de QA precisa testar:

• Cadastro de clientes
• Processamento de pedidos
• Cálculo de frete por CEP e estado
• Relatórios gerenciais por região
• Sistema de nota fiscal eletrônica

Solução com CPF Aleatório: Geram 10.000 CPFs aleatórios e importam para o banco de dados de teste. Com isso, têm clientes "espalhados" por todo o Brasil. Os testes de frete funcionam para todas as regiões automaticamente. Os relatórios mostram uma distribuição geográfica realista.

Sem CPFs aleatórios, teriam que gerar manualmente CPFs de cada estado, um trabalho tedioso e sujeito a erros.

Caso 2: Sistema Bancário em Homologação

Um banco está testando uma nova funcionalidade de abertura de conta digital. Precisam simular:

• 50.000 aberturas de conta em um mês
• Clientes de todas as regiões do país
• Detecção de fraudes (CPFs duplicados)
• Performance do sistema sob carga

Solução com CPF Aleatório: Geram 50.000 CPFs aleatórios únicos. Criam scripts que simulam aberturas de conta usando esses CPFs ao longo de 30 dias virtuais. O sistema de anti-fraude é testado com dados diversos. A performance é validada com carga realista.

A aleatoriedade garante que não há padrões que possam mascarar bugs. Se houvesse um problema específico com CPFs do Acre, por exemplo, seria detectado naturalmente.

Caso 3: Aplicativo de Delivery

Um aplicativo de entregas precisa:

• Cadastrar restaurantes e entregadores
• Validar CPFs no ato do cadastro
• Gerar relatórios fiscais por estado
• Testar integração com APIs de pagamento

Solução com CPF Aleatório: Usam CPFs aleatórios para criar perfis de teste de restaurantes, entregadores e clientes. Isso permite testar todo o fluxo sem usar dados reais de pessoas. A validação funciona perfeitamente porque os CPFs são matematicamente corretos.

Os relatórios fiscais mostram distribuição realista por UF, facilitando a validação das regras de negócio estaduais.

Caso 4: Sistema de RH Corporativo

Uma empresa de software vende um sistema de folha de pagamento. Durante demos para clientes, precisam mostrar:

• Base de funcionários realista
• Relatórios de encargos por região
• Cálculos de IR e INSS corretos
• Dashboards gerenciais

Solução com CPF Aleatório: Criam uma base demo com 5.000 "funcionários" usando CPFs aleatórios. Cada demo mostra dados diferentes, dando impressão de sistema robusto. Os clientes veem uma distribuição natural de funcionários por estado, tornando a demonstração mais convincente.

Usar sempre os mesmos CPFs deixaria a demo artificial e pouco profissional.

Caso 5: Plataforma de Educação Online

Uma edtech precisa:

• Cadastrar alunos em cursos
• Emitir certificados digitais
• Processar pagamentos via boleto e cartão
• Gerar relatórios para secretarias de educação

Solução com CPF Aleatório: Durante a fase de testes, geram 100.000 CPFs aleatórios para simular alunos. Testam todos os fluxos: matrícula, pagamento, emissão de certificado, cancelamento. A variedade de CPFs garante que edge cases sejam descobertos.

Em produção, orientam desenvolvedores a NUNCA usar esses CPFs de teste em produção, apenas em staging e desenvolvimento. Para diferenciar CPFs válidos de CPFs reais, leia nosso guia sobre CPF fake vs CPF real.

Erros Comuns ao Trabalhar com CPFs Aleatórios

AMesmo com CPFs válidos e aleatórios, alguns erros são frequentes. Vamos ver os principais e como evitá-los.

Erro 1: Usar CPF Aleatório em Produção

O problema: Desenvolvedores esquecem CPFs de teste no código e eles acabam sendo usados em produção.

Consequência: Usuários reais são cadastrados com CPFs fake, causando problemas fiscais, rejeição em sistemas de pagamento e possíveis questões legais.

Solução:

• Mantenha ambientes completamente separados (dev/staging/prod)
• Use variáveis de ambiente para distinguir contextos
• Nunca faça commit de CPFs hardcoded
• Implemente validações que rejeitam CPFs de teste conhecidos em produção

Erro 2: Não Validar CPFs Gerados

O problema: Confiar cegamente que o gerador está correto sem validar os números produzidos.

Agora vamos para a parte que todo desenvolvedor estava esperando: como implementar validação de CPF no código. Seja você um programador front-end que precisa validar formulários, ou back-end construindo APIs, você vai encontrar aqui exemplos prontos para usar.

A grande vantagem de implementar a validação no código é ter controle total sobre o processo. Você valida instantaneamente sem depender de serviços externos, pode customizar mensagens de erro, integrar com seu fluxo de trabalho e até adicionar logs para detectar tentativas de fraude.

Além disso, validação client-side (no navegador) melhora a experiência do usuário. A pessoa digita o CPF e recebe feedback imediato se está correto, sem precisar enviar o formulário e esperar a resposta do servidor. Isso reduz frustrações e aumenta conversões.

Vou te mostrar implementações completas e testadas em JavaScript, Python e PHP. Todos os códigos seguem as melhores práticas, têm comentários explicativos e são prontos para copiar e colar nos seus projetos.

// ❌ ERRADO - CPF hardcoded

const cpfTeste = '12345678909';

// ✅ CORRETO - Gerado dinamicamente apenas em ambiente de teste

const cpfTeste = process.env.NODE_ENV === 'development'

    ? gerarCPFAleatorio()

    : null;

Erro 3: Gerar CPFs Duplicados

O problema: Em lotes grandes, não verificar se há CPFs repetidos.

Consequência: Testes falham porque o banco de dados rejeita duplicatas, ou você não detecta problemas de unique constraint.

Solução: Use um Set ou equivalente para garantir unicidade:

def gerar_cpfs_unicos(quantidade):
cpfs = set() # Set garante unicidade
while len(cpfs) < quantidade:
cpfs.add(gerar_cpf_aleatorio())
return list(cpfs)

Erro 4: Ignorar a Distribuição Geográfica

O problema: Esquecer que CPFs aleatórios terão distribuição aproximadamente uniforme de estados, o que pode não representar a realidade brasileira.

Consequência: Seus dados de teste não refletem que São Paulo tem muito mais CPFs que Roraima, podendo mascarar problemas de escala.

Solução: Para dados mais realistas, pondere a geração:

import random

DISTRIBUICAO_ESTADOS = {
8: 40, # São Paulo - 40% dos CPFs
7: 15, # Rio de Janeiro - 15%
6: 10, # Minas Gerais - 10%
9: 8, # Paraná/SC - 8%
# … outros estados com proporções menores
}

def gerar_cpf_ponderado():
# Escolhe estado com base na distribuição real
estado = random.choices(
list(DISTRIBUICAO_ESTADOS.keys()),
weights=list(DISTRIBUICAO_ESTADOS.values())
)[0]

Erro 5: Não Documentar os Dados de Teste

O problema: Gerar milhares de CPFs e não documentar quais são de teste.

Consequência: Confusão entre dados de teste e produção, dificuldade em limpar bases, riscos de compliance.

Solução:

• Mantenha um arquivo com todos os CPFs de teste gerados
• Use prefixos em outros campos (nome = "TESTE - João Silva")
• Documente a origem dos dados em cada ambiente
• Crie scripts de limpeza para remover dados de teste

Perguntas Frequentes Sobre CPF Aleatório

Aprenda Mais Sobre Geração e Validação de CPF

Aprofunde seus conhecimentos sobre CPF com nossos outros guias completos:

Conclusão: Você Agora é Expert em Validação de CPF

CPF aleatório é uma ferramenta essencial no arsenal de qualquer desenvolvedor, testador ou profissional de TI que trabalha com sistemas brasileiros. A capacidade de gerar números válidos sem padrões geográficos específicos abre possibilidades enormes para testes abrangentes, bancos de dados realistas e simulações profissionais.

Você aprendeu neste guia que CPF aleatório não significa CPF inválido - muito pelo contrário. São números matematicamente corretos, gerados com aleatoriedade genuína, perfeitos para representar a diversidade de usuários que um sistema real encontraria em produção.

A escolha entre CPF aleatório e CPF regional depende do seu cenário de uso. Para testes gerais, populamento de bases e máxima cobertura, sempre prefira aleatório. Para casos específicos de validação regional ou demonstrações focadas, CPF de estado específico pode ser mais apropriado.

Lembre-se sempre: CPFs aleatórios são exclusivamente para desenvolvimento, testes e educação. Nunca os use em situações reais, cadastros oficiais ou contextos que possam configurar fraude. Use seu CPF real quando a situação exigir identificação verdadeira.