Guia Completo: Algoritmo de Validação de CPF

O CPF (Cadastro de Pessoas Físicas) é o documento mais utilizado em sistemas brasileiros. Saber validar corretamente um CPF é essencial para qualquer desenvolvedor que trabalha com cadastros, e-commerce ou sistemas fiscais no Brasil.

Neste guia, vamos explicar o algoritmo oficial da Receita Federal, implementá-lo em múltiplas linguagens e mostrar os erros mais comuns que desenvolvedores cometem.

O Que É o CPF?

O CPF é um número de 11 dígitos no formato XXX.XXX.XXX-DD, onde os dois últimos dígitos (DD) são dígitos verificadores calculados a partir dos 9 primeiros. É esse cálculo que permite validar se um CPF é matematicamente válido.

Como Funciona o Algoritmo

O algoritmo de validação do CPF usa o método de módulo 11 em duas etapas:

Passo 1: Calcular o primeiro dígito verificador

1. Multiplique os 9 primeiros dígitos por pesos decrescentes: 10, 9, 8, 7, 6, 5, 4, 3, 2
2. Some todos os resultados
3. Calcule o resto da divisão por 11
4. Se o resto for menor que 2, o dígito é 0. Senão, o dígito é 11 - resto

Passo 2: Calcular o segundo dígito verificador

1. Multiplique os 10 primeiros dígitos (incluindo o primeiro verificador) por pesos: 11, 10, 9, 8, 7, 6, 5, 4, 3, 2
2. Repita o mesmo cálculo do módulo 11

Exemplo prático

Para o CPF 529.982.247-25:

Dígitos: 5 2 9 9 8 2 2 4 7
Pesos:  10 9 8 7 6 5 4 3 2

5×10 + 2×9 + 9×8 + 9×7 + 8×6 + 2×5 + 2×4 + 4×3 + 7×2
= 50 + 18 + 72 + 63 + 48 + 10 + 8 + 12 + 14 = 295

295 % 11 = 9 → 11 - 9 = 2 ✅ (primeiro dígito)

Implementação em JavaScript

function validarCPF(cpf) {
  // Remove caracteres não numéricos
  cpf = cpf.replace(/\D/g, '');
  
  // Verifica se tem 11 dígitos
  if (cpf.length !== 11) return false;
  
  // Rejeita CPFs com todos os dígitos iguais (ex: 111.111.111-11)
  if (/^(\d)\1{10}$/.test(cpf)) return false;
  
  // Calcula o primeiro dígito verificador
  let soma = 0;
  for (let i = 0; i < 9; i++) {
    soma += parseInt(cpf.charAt(i)) * (10 - i);
  }
  let resto = (soma * 10) % 11;
  if (resto === 10) resto = 0;
  if (resto !== parseInt(cpf.charAt(9))) return false;
  
  // Calcula o segundo dígito verificador
  soma = 0;
  for (let i = 0; i < 10; i++) {
    soma += parseInt(cpf.charAt(i)) * (11 - i);
  }
  resto = (soma * 10) % 11;
  if (resto === 10) resto = 0;
  if (resto !== parseInt(cpf.charAt(10))) return false;
  
  return true;
}

// Exemplos de uso
console.log(validarCPF('529.982.247-25')); // true
console.log(validarCPF('111.111.111-11')); // false

Implementação em Python

def validar_cpf(cpf: str) -> bool:
    # Remove caracteres não numéricos
    cpf = ''.join(filter(str.isdigit, cpf))
    
    # Verifica se tem 11 dígitos
    if len(cpf) != 11:
        return False
    
    # Rejeita CPFs com todos os dígitos iguais
    if cpf == cpf[0] * 11:
        return False
    
    # Calcula o primeiro dígito verificador
    soma = sum(int(cpf[i]) * (10 - i) for i in range(9))
    resto = (soma * 10) % 11
    if resto == 10:
        resto = 0
    if resto != int(cpf[9]):
        return False
    
    # Calcula o segundo dígito verificador
    soma = sum(int(cpf[i]) * (11 - i) for i in range(10))
    resto = (soma * 10) % 11
    if resto == 10:
        resto = 0
    if resto != int(cpf[10]):
        return False
    
    return True

# Exemplos de uso
print(validar_cpf('529.982.247-25'))  # True
print(validar_cpf('111.111.111-11'))  # False

Implementação em Java

public class CPFValidator {
    public static boolean validar(String cpf) {
        cpf = cpf.replaceAll("\\D", "");
        
        if (cpf.length() != 11) return false;
        if (cpf.matches("(\\d)\\1{10}")) return false;
        
        // Primeiro dígito verificador
        int soma = 0;
        for (int i = 0; i < 9; i++) {
            soma += Character.getNumericValue(cpf.charAt(i)) * (10 - i);
        }
        int resto = (soma * 10) % 11;
        if (resto == 10) resto = 0;
        if (resto != Character.getNumericValue(cpf.charAt(9))) return false;
        
        // Segundo dígito verificador
        soma = 0;
        for (int i = 0; i < 10; i++) {
            soma += Character.getNumericValue(cpf.charAt(i)) * (11 - i);
        }
        resto = (soma * 10) % 11;
        if (resto == 10) resto = 0;
        if (resto != Character.getNumericValue(cpf.charAt(10))) return false;
        
        return true;
    }
}

Erros Comuns na Validação

1. Não rejeitar CPFs com dígitos iguais: CPFs como 000.000.000-00 e 111.111.111-11 passam no algoritmo de módulo 11 mas são inválidos.
2. Esquecer de limpar a máscara: Sempre remova pontos e traços antes de validar.
3. Confundir validação com verificação: Validar matematicamente é diferente de consultar na Receita Federal.
4. Usar dados reais em testes: Use geradores de CPF para criar dados fictícios válidos.

Perguntas Frequentes

Posso usar CPFs gerados em produção?

Não. CPFs gerados por ferramentas são para testes de software apenas. Usar dados fictícios em cadastros reais é ilegal.

O que é o dígito verificador?

São os dois últimos dígitos do CPF, calculados matematicamente a partir dos 9 primeiros. Servem como "checksum" para detectar erros de digitação.

Por que existem CPFs inválidos com dígitos iguais?

CPFs como 111.111.111-11 passam no algoritmo de módulo 11 por uma coincidência matemática. Por isso, uma verificação adicional é necessária.