Todo desenvolvedor que já mexeu com cadastro de usuário no Brasil esbarrou nisso: o formulário precisa aceitar um CPF, e você precisa decidir se aquele número faz sentido antes de mandar pro banco de dados. A pergunta que aparece é sempre a mesma: dá pra saber se um CPF é válido só olhando os números, sem consultar a Receita Federal? A resposta é sim, e o segredo está nos dois últimos dígitos.
Neste post a gente vai destrinchar como validar CPF na prática, do jeito que funciona de verdade. Vou explicar o algoritmo do dígito verificador passo a passo, com um exemplo numérico completo, e depois entregar código pronto e testado em JavaScript, Python e PHP. No fim você vai saber exatamente por que 111.111.111-11 passa na matemática mas nunca deve ser aceito, e como gerar CPFs válidos para popular seu ambiente de testes sem usar dado de gente real.
O que significa validar um CPF (e a estrutura do número)
Validar um CPF é conferir se aquela sequência de 11 dígitos obedece à regra matemática que a Receita Federal usa para montar o número. Atenção a uma distinção importante: validar não é o mesmo que verificar se o CPF existe ou está ativo. A validação local só diz que o número é matematicamente consistente. Para saber se ele pertence a uma pessoa real e está regular, você precisaria consultar uma base oficial, o que é outra história.
Na prática, essa validação local resolve 90% dos casos do dia a dia: barra erro de digitação, rejeita número inventado na sorte e evita que lixo entre no seu sistema. É rápida, roda no navegador ou no servidor, e não depende de internet nem de API paga.
O CPF tem 11 dígitos, e eles se dividem em duas partes. Os 9 primeiros formam o número base, que é sequencial e inclui uma referência à região fiscal onde o CPF foi emitido. Os 2 últimos são os dígitos verificadores, calculados a partir dos 9 primeiros. São esses dois dígitos que tornam a validação possível sem consultar ninguém: eles funcionam como um checksum, um resultado matemático que só bate se o número base estiver correto.
| Posição | Dígitos | Função |
|---|---|---|
| 1 a 9 | Número base | Sequência com referência à região fiscal |
| 10 | 1º dígito verificador | Calculado sobre os 9 primeiros |
| 11 | 2º dígito verificador | Calculado sobre os 10 primeiros |
Quando você vê um CPF formatado como 529.982.247-25, os pontos e o traço são só enfeite visual para leitura humana. O que importa para o algoritmo são os 11 dígitos crus: 52998224725. A primeira coisa que qualquer rotina de validação faz é limpar essa máscara, jogando fora tudo que não for número.
Como funciona o dígito verificador
O dígito verificador é um número calculado a partir dos outros para detectar erros. A mesma ideia aparece no código de barras, no ISBN de livros e no CNPJ. No caso do CPF, a técnica usada é o módulo 11, que é boa porque pega tanto erro de digitação de um dígito quanto troca de posição entre dois dígitos vizinhos, que são os erros mais comuns quando alguém digita rápido.
A lógica central é esta: cada dígito do número base recebe um peso, você multiplica dígito por peso, soma tudo, e o resto dessa soma dividida por 11 determina o dígito verificador. Como o CPF tem dois verificadores, o processo roda duas vezes. Primeiro a gente calcula o 1º dígito usando os 9 do número base. Depois calcula o 2º dígito usando os 9 do base mais o 1º verificador que acabamos de achar, num total de 10 dígitos.
Os pesos não são aleatórios: eles são decrescentes e começam num valor diferente para cada verificador. Para o 1º dígito, os pesos vão de 10 até 2. Para o 2º dígito, como entra um dígito a mais na conta, os pesos vão de 11 até 2. A tabela abaixo deixa isso claro.
| Dígito do número | Peso p/ 1º DV | Peso p/ 2º DV |
|---|---|---|
| 1º | 10 | 11 |
| 2º | 9 | 10 |
| 3º | 8 | 9 |
| 4º | 7 | 8 |
| 5º | 6 | 7 |
| 6º | 5 | 6 |
| 7º | 4 | 5 |
| 8º | 3 | 4 |
| 9º | 2 | 3 |
| 10º (1º DV) | não usa | 2 |
Depois de somar todos os produtos, aplica-se a regra do módulo 11. Calcula-se o resto da soma dividida por 11, e faz-se 11 menos esse resto. Se o resultado for 10 ou 11 (ou seja, maior que 9), o dígito verificador é 0. Caso contrário, o dígito é o próprio resultado. Essa é a parte que confunde muita gente na primeira leitura, então vamos ver com números reais.
O algoritmo passo a passo com exemplo numérico
Vou usar o CPF 529.982.247-25, que é um número válido bastante conhecido em exemplos de código. Nosso trabalho é calcular os dois dígitos verificadores a partir do número base 529982247 e conferir se batem com o 25 do fim.
Passo 1: calcular o 1º dígito verificador
Pegamos os 9 dígitos do base (5, 2, 9, 9, 8, 2, 2, 4, 7) e multiplicamos cada um pelos pesos de 10 a 2. Fica assim: 5×10 mais 2×9 mais 9×8 mais 9×7 mais 8×6 mais 2×5 mais 2×4 mais 4×3 mais 7×2. Isso dá 50 mais 18 mais 72 mais 63 mais 48 mais 10 mais 8 mais 12 mais 14, que soma 295.
Agora o módulo 11. O resto de 295 dividido por 11 é 9 (porque 11 vezes 26 dá 286, e sobram 9). Fazemos 11 menos 9, que dá 2. Como 2 não é maior que 9, o 1º dígito verificador é 2. Confere com o primeiro dígito do “25” no fim do CPF.
Passo 2: calcular o 2º dígito verificador
Agora entram 10 dígitos: os 9 do base mais o 1º DV que achamos (5, 2, 9, 9, 8, 2, 2, 4, 7, 2), multiplicados pelos pesos de 11 a 2. Fica: 5×11 mais 2×10 mais 9×9 mais 9×8 mais 8×7 mais 2×6 mais 2×5 mais 4×4 mais 7×3 mais 2×2. Isso é 55 mais 20 mais 81 mais 72 mais 56 mais 12 mais 10 mais 16 mais 21 mais 4, que soma 347.
O resto de 347 dividido por 11 é 6 (11 vezes 31 dá 341, sobram 6). Fazemos 11 menos 6, que dá 5. Como 5 não passa de 9, o 2º dígito verificador é 5. Bate com o segundo dígito do “25”. Os dois verificadores calculados são 2 e 5, exatamente o que estava no CPF, então o número é válido.
| Etapa | 1º DV | 2º DV |
|---|---|---|
| Soma dos produtos | 295 | 347 |
| Resto (soma % 11) | 9 | 6 |
| 11 menos o resto | 2 | 5 |
| Dígito final | 2 | 5 |
É esse mesmo procedimento, repetido em código, que valida qualquer CPF. Note uma coisa: se você mudar um único dígito do número base, a soma muda, o resto muda, e os verificadores calculados não vão mais bater com os que estão no número. É exatamente por isso que o esquema pega erro de digitação.
Código de validação em JavaScript, Python e PHP
Agora a parte que você provavelmente veio buscar: código pronto. As três implementações seguem a mesma lógica, limpam a máscara, rejeitam tamanho errado, rejeitam dígitos todos iguais, calculam os dois verificadores e comparam. Copie, cole e adapte ao seu projeto.
JavaScript
function validarCPF(cpf) {
// Remove tudo que não for dígito
cpf = String(cpf).replace(/\D/g, '');
// Precisa ter exatamente 11 dígitos
if (cpf.length !== 11) return false;
// Rejeita sequências de dígitos iguais (000..., 111..., etc)
if (/^(\d)\1{10}$/.test(cpf)) return false;
// Função auxiliar: calcula um dígito verificador
const calcDigito = (base, pesoInicial) => {
let soma = 0;
for (let i = 0; i < base.length; i++) {
soma += Number(base[i]) * (pesoInicial - i);
}
const resto = 11 - (soma % 11);
return resto > 9 ? 0 : resto;
};
const dv1 = calcDigito(cpf.slice(0, 9), 10);
const dv2 = calcDigito(cpf.slice(0, 10), 11);
return dv1 === Number(cpf[9]) && dv2 === Number(cpf[10]);
}
// Exemplos
console.log(validarCPF('529.982.247-25')); // true
console.log(validarCPF('111.111.111-11')); // false
console.log(validarCPF('529.982.247-24')); // falsePython
import re
def validar_cpf(cpf: str) -> bool:
# Remove tudo que não for dígito
cpf = re.sub(r'\D', '', str(cpf))
# Precisa ter exatamente 11 dígitos
if len(cpf) != 11:
return False
# Rejeita sequências de dígitos iguais
if cpf == cpf[0] * 11:
return False
def calc_digito(base: str, peso_inicial: int) -> int:
soma = sum(int(d) * (peso_inicial - i) for i, d in enumerate(base))
resto = 11 - (soma % 11)
return 0 if resto > 9 else resto
dv1 = calc_digito(cpf[:9], 10)
dv2 = calc_digito(cpf[:10], 11)
return dv1 == int(cpf[9]) and dv2 == int(cpf[10])
# Exemplos
print(validar_cpf('529.982.247-25')) # True
print(validar_cpf('111.111.111-11')) # False
print(validar_cpf('529.982.247-24')) # FalsePHP
<?php
function validarCPF($cpf) {
// Remove tudo que não for dígito
$cpf = preg_replace('/\D/', '', (string) $cpf);
// Precisa ter exatamente 11 dígitos
if (strlen($cpf) !== 11) {
return false;
}
// Rejeita sequências de dígitos iguais
if (preg_match('/^(\d)\1{10}$/', $cpf)) {
return false;
}
$calcDigito = function ($base, $pesoInicial) {
$soma = 0;
for ($i = 0; $i < strlen($base); $i++) {
$soma += intval($base[$i]) * ($pesoInicial - $i);
}
$resto = 11 - ($soma % 11);
return $resto > 9 ? 0 : $resto;
};
$dv1 = $calcDigito(substr($cpf, 0, 9), 10);
$dv2 = $calcDigito(substr($cpf, 0, 10), 11);
return $dv1 == intval($cpf[9]) && $dv2 == intval($cpf[10]);
}
// Exemplos
var_dump(validarCPF('529.982.247-25')); // bool(true)
var_dump(validarCPF('111.111.111-11')); // bool(false)
var_dump(validarCPF('529.982.247-24')); // bool(false)
?>Repare que nas três linguagens a função auxiliar recebe um peso inicial e vai decrementando conforme percorre os dígitos. Isso evita duplicar o laço para os dois verificadores, e deixa o código mais limpo. Se você preferir, dá pra escrever os pesos como um array fixo, mas na minha experiência a versão com peso decrescente é mais fácil de manter.
Como gerar um CPF válido para testes
Quando você está desenvolvendo, precisa de CPFs válidos para preencher formulários, rodar testes automatizados e popular banco de dados de homologação. Digitar 529.982.247-25 toda vez cansa, e você quer variedade. A boa notícia é que gerar um CPF válido é só inverter o algoritmo: sorteie 9 dígitos aleatórios para o número base e calcule os dois verificadores em cima deles.
Aqui vai uma função em JavaScript que faz isso, reaproveitando a mesma lógica de cálculo que já vimos:
function gerarCPF() {
// Sorteia os 9 dígitos do número base
let base = '';
for (let i = 0; i < 9; i++) {
base += Math.floor(Math.random() * 10);
}
const calcDigito = (num, pesoInicial) => {
let soma = 0;
for (let i = 0; i < num.length; i++) {
soma += Number(num[i]) * (pesoInicial - i);
}
const resto = 11 - (soma % 11);
return resto > 9 ? 0 : resto;
};
const dv1 = calcDigito(base, 10);
const dv2 = calcDigito(base + dv1, 11);
return base + dv1 + dv2;
}
console.log(gerarCPF()); // ex: 39053344705Um aviso ético que eu faço questão de deixar bem claro: esses CPFs gerados são válidos apenas do ponto de vista matemático. Use exclusivamente em ambiente de teste, homologação e desenvolvimento. Nunca use um CPF gerado assim para se passar por outra pessoa, burlar cadastro, fraudar sistema ou qualquer coisa parecida, porque um número que você sorteou pode, por coincidência, pertencer a uma pessoa real, e usar CPF de terceiro para fraude é crime. Gerador de CPF é ferramenta de desenvolvedor, não instrumento de golpe.
Erros comuns na validação de CPF
Depois de ver muito código de validação por aí, alguns tropeços aparecem sempre. Vale listar para você não cair neles.
- Esquecer de limpar a máscara. Se a função não remove pontos e traço antes de contar os dígitos, um CPF formatado vai ter 14 caracteres e ser rejeitado por engano. Sempre rode um replace tirando tudo que não é número logo no começo.
- Não rejeitar dígitos repetidos. Sequências como 000.000.000-00 e 111.111.111-11 passam na conta do módulo 11, porque a matemática fecha, mas são CPFs inválidos por definição. Sem o teste explícito de dígitos iguais, sua validação deixa passar esses números.
- Confundir o resto com o dígito. O dígito verificador não é o resto da divisão por 11, e sim o resultado de 11 menos esse resto, com a regra de virar 0 quando passa de 9. Pular esse detalhe é o bug mais frequente.
- Comparar string com número sem cuidado. Em linguagens com tipagem frouxa, comparar o dígito calculado (número) com o dígito do CPF (caractere) pode dar resultado inesperado. Converta os dois para o mesmo tipo antes de comparar.
- Achar que validação local confirma existência. Já falei, mas repito porque é importante: passar na validação matemática não quer dizer que o CPF existe ou está regular na Receita. São coisas diferentes.
Se você trata cadastro de empresa também, a mesma família de problemas aparece no CNPJ, que usa módulo 11 com uma lógica de pesos parecida. Se quiser, dá uma olhada em como validar um CNPJ para comparar as duas rotinas lado a lado.
Perguntas frequentes
Validar CPF localmente confirma que ele existe na Receita Federal?
Não. A validação por algoritmo só verifica se o número é matematicamente consistente, ou seja, se os dígitos verificadores batem com o número base. Ela não diz se aquele CPF foi realmente emitido, se pertence a alguém ou se está regular. Para isso você precisaria de uma consulta a uma base oficial, que envolve autorização e é um serviço à parte.
Por que 111.111.111-11 é rejeitado se a matemática fecha?
Porque CPFs com todos os dígitos iguais são considerados inválidos por convenção, mesmo passando no cálculo do módulo 11. São onze casos assim (de 000.000.000-00 a 999.999.999-99) e todos precisam ser barrados explicitamente no código, com um teste que detecta a sequência repetida antes de calcular os verificadores.
Preciso validar CPF no front-end ou no back-end?
Nos dois. No front-end a validação dá retorno imediato ao usuário e melhora a experiência, evitando um round-trip ao servidor por causa de um erro de digitação. No back-end ela é obrigatória por segurança, porque validação de cliente pode ser burlada. Nunca confie só no JavaScript do navegador para garantir a integridade dos dados.
O algoritmo do dígito verificador do CPF é o mesmo do CNPJ?
A base é a mesma, o módulo 11, mas os detalhes mudam. O CNPJ tem 14 dígitos, usa uma sequência de pesos diferente e, na versão alfanumérica que passou a valer, trata letras convertendo caracteres para valores numéricos. A ideia de multiplicar por pesos, somar e tirar o módulo 11 é idêntica, mas você não pode reaproveitar a função do CPF direto no CNPJ.
Posso usar uma biblioteca pronta em vez de escrever o código?
Pode, e em projeto grande costuma valer a pena. Existem pacotes maduros em npm, PyPI e Packagist que validam CPF e já cobrem casos de borda. Ainda assim, entender o algoritmo importa, porque você vai saber depurar quando algo der errado e não vai tratar a biblioteca como caixa-preta. Para um único formulário, a função de vinte linhas que você viu aqui resolve sem adicionar dependência.
Qual a diferença entre validar e formatar um CPF?
Formatar é aplicar a máscara visual, transformando 52998224725 em 529.982.247-25 para o número ficar legível. Validar é conferir se os dígitos verificadores estão corretos. São operações independentes: você pode formatar um CPF inválido e pode validar um CPF sem máscara. No fluxo típico, você limpa a máscara, valida os dígitos crus e só formata de volta para exibir.
Conclusão
Validar CPF é um daqueles problemas que parecem misteriosos até você abrir a caixa e ver que são só duas contas de módulo 11 encadeadas. Com o número base em mãos, você multiplica pelos pesos decrescentes, soma, tira o resto da divisão por 11, faz 11 menos o resto, trata o caso de passar de 9, e pronto: tem o dígito verificador. Repete para o segundo dígito incluindo o primeiro na conta, compara com o que veio no número, e a validação está feita.
O que separa uma implementação correta de uma furada são os detalhes que a gente cobriu: limpar a máscara antes de tudo, rejeitar os dígitos repetidos que enganam a matemática, e lembrar que validar não confirma existência. Com as funções em JavaScript, Python e PHP que estão aqui, você tem uma base sólida pra plugar no seu formulário hoje mesmo, e o gerador de CPF resolve a vida na hora de montar seus testes. Se for validar CNPJ também, o raciocínio é o mesmo, só mudam os pesos e o tamanho do número.
Se você precisa validar e consultar CPF em escala no seu sistema, o Hub do Desenvolvedor oferece uma API de consulta de CPF que traz a situação cadastral direto da Receita Federal.
