Como fazer validação de dígitos verificadores do CPF em qualquer linguagem

Para validar os dígitos verificadores do CPF em qualquer linguagem, aplique o algoritmo em duas etapas: multiplique os 9 primeiros dígitos por pesos decrescentes, calcule o resto da divisão por 11 e determine cada dígito verificador. A validação sintática funciona de forma local e instantânea, mas não garante que o CPF pertence a uma pessoa real — para isso, é necessário combinar com uma consulta via API.

Introdução

O CPF (Cadastro de Pessoas Físicas) é composto por 11 dígitos, sendo os dois últimos os chamados dígitos verificadores. Esses dígitos são calculados a partir dos nove primeiros usando um algoritmo matemático específico, e sua validação é a primeira linha de defesa contra a inserção de documentos inválidos em qualquer sistema.

Também veremos como combinar essa validação local com a consulta via API para garantir que o CPF pertence a uma pessoa real.

Como funciona o algoritmo dos dígitos verificadores

O CPF tem o formato XXX.XXX.XXX-DD, onde D representa os dígitos verificadores. O cálculo é feito em duas etapas.

Cálculo do primeiro dígito verificador (10o dígito)

1. Multiplique cada um dos 9 primeiros dígitos por pesos de 10 a 2, respectivamente.
2. Some todos os resultados.
3. Calcule o resto da divisão da soma por 11.
4. Se o resto for menor que 2, o dígito é 0. Caso contrário, o dígito é 11 menos o resto.

Cálculo do segundo dígito verificador (11o dígito)

1. Multiplique cada um dos 10 primeiros dígitos (incluindo o primeiro verificador) por pesos de 11 a 2.
2. Some todos os resultados.
3. Aplique a mesma regra: se o resto da divisão por 11 for menor que 2, o dígito é 0; caso contrário, é 11 menos o resto.

Regra adicional: sequências repetidas

CPFs com todos os dígitos iguais (como 111.111.111-11 ou 000.000.000-00) passam no cálculo matemático, mas são considerados inválidos. Sua implementação deve rejeitar essas sequências.

Implementação em Python

def validar_cpf(cpf):
    cpf = ''.join(filter(str.isdigit, cpf))

    if len(cpf) != 11:
    return False

    if cpf == cpf[0] * 11:
    return False

    # Primeiro dígito verificador
    soma = sum(int(cpf[i]) * (10 - i) for i in range(9))
    resto = soma % 11
    digito1 = 0 if resto < 2 else 11 - resto

    if int(cpf[9]) != digito1:
    return False

    # Segundo dígito verificador
    soma = sum(int(cpf[i]) * (11 - i) for i in range(10))
    resto = soma % 11
    digito2 = 0 if resto < 2 else 11 - resto

    return int(cpf[10]) == digito2

# Testes
print(validar_cpf("529.982.247-25")) # True ou False conforme o CPF

Implementação em JavaScript

function validarCPF(cpf) {
    cpf = cpf.replace(/\D/g, '');

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

    // Primeiro dígito verificador
    let soma = 0;
    for (let i = 0; i < 9; i++) {
    soma += parseInt(cpf[i]) * (10 - i);
    }
    let resto = soma % 11;
    let digito1 = resto < 2 ? 0 : 11 - resto;

    if (parseInt(cpf[9]) !== digito1) return false;

    // Segundo dígito verificador
    soma = 0;
    for (let i = 0; i < 10; i++) {
    soma += parseInt(cpf[i]) * (11 - i);
    }
    resto = soma % 11;
    let digito2 = resto < 2 ? 0 : 11 - resto;

    return parseInt(cpf[10]) === digito2;
}

Implementação em Go

package main

import (
    "fmt"
    "strconv"
    "strings"
    "unicode"
)

func validarCPF(cpf string) bool {
    var digits []int
    for _, r := range cpf {
    if unicode.IsDigit(r) {
    d, _ := strconv.Atoi(string(r))
    digits = append(digits, d)
    }
    }

    if len(digits) != 11 {
    return false
    }

    // Verificar sequência repetida
    allSame := true
    for i := 1; i < 11; i++ {
    if digits[i] != digits[0] {
    allSame = false
    break
    }
    }
    if allSame {
    return false
    }

    // Primeiro dígito
    soma := 0
    for i := 0; i < 9; i++ {
    soma += digits[i] * (10 - i)
    }
    resto := soma % 11
    d1 := 0
    if resto >= 2 {
    d1 = 11 - resto
    }
    if digits[9] != d1 {
    return false
    }

    // Segundo dígito
    soma = 0
    for i := 0; i < 10; i++ {
    soma += digits[i] * (11 - i)
    }
    resto = soma % 11
    d2 := 0
    if resto >= 2 {
    d2 = 11 - resto
    }
    return digits[10] == d2
}

func main() {
    fmt.Println(validarCPF("529.982.247-25"))
}

Implementação em PHP

<?php
function validarCPF(string $cpf): bool {
    $cpf = preg_replace('/\D/', '', $cpf);

    if (strlen($cpf) !== 11) return false;
    if (preg_match('/^(\d)\1{10}$/', $cpf)) return false;

    // Primeiro dígito
    $soma = 0;
    for ($i = 0; $i < 9; $i++) {
    $soma += intval($cpf[$i]) * (10 - $i);
    }
    $resto = $soma % 11;
    $digito1 = $resto < 2 ? 0 : 11 - $resto;

    if (intval($cpf[9]) !== $digito1) return false;

    // Segundo dígito
    $soma = 0;
    for ($i = 0; $i < 10; $i++) {
    $soma += intval($cpf[$i]) * (11 - $i);
    }
    $resto = $soma % 11;
    $digito2 = $resto < 2 ? 0 : 11 - $resto;

    return intval($cpf[10]) === $digito2;
}

echo validarCPF("529.982.247-25") ? "Válido" : "Inválido";

Limitação da validação sintática

A validação dos dígitos verificadores confirma apenas que o formato do CPF é matematicamente correto. Ela não garante que:

• O CPF pertence a uma pessoa real.
• O CPF está ativo.
• Os dados informados (nome, data de nascimento) correspondem ao titular.

Para obter essas informações, é necessário consultar uma API que retorne dados cadastrais reais.

Combinando validação local com consulta via API

A melhor prática é usar a validação sintática como filtro inicial e, em seguida, consultar a API apenas para CPFs que passaram nessa primeira etapa:

import requests

def validar_cpf_completo(cpf):
    # Etapa 1: Validação sintática local
    if not validar_cpf(cpf):
    return {"valido": False, "motivo": "Dígitos verificadores inválidos"}

    # Etapa 2: Consulta via API
    cpf_limpo = ''.join(filter(str.isdigit, cpf))
    url = f"https://api.cpfhub.io/cpf/{cpf_limpo}"
    headers = {
    "x-api-key": "SUA_CHAVE_DE_API",
    "Accept": "application/json"
    }

    try:
    response = requests.get(url, headers=headers, timeout=10)
    dados = response.json()

    if dados.get("success"):
    return {
    "valido": True,
    "nome": dados["data"]["name"],
    "nascimento": dados["data"]["birthDate"]
    }
    else:
    return {"valido": False, "motivo": "CPF não encontrado na base"}

    except requests.exceptions.Timeout:
    return {"valido": False, "motivo": "Timeout na consulta"}

resultado = validar_cpf_completo("529.982.247-25")
print(resultado)

Essa abordagem em duas etapas economiza requisições à API, já que CPFs com formato inválido são rejeitados localmente sem consumir créditos de consulta.

Perguntas frequentes

O que é necessário para implementar validação de CPF neste contexto?

A validação de CPF exige uma chamada à API com o número do documento e a chave de autenticação. A CPFHub.io retorna o status do CPF, nome do titular e data de nascimento em menos de 200ms, permitindo a verificação em tempo real durante o cadastro ou transação.

A API CPFHub.io funciona para todos os volumes de consulta?

Sim. O plano gratuito oferece 50 consultas por mês sem cartão de crédito — ideal para testes e projetos pequenos. Para volumes maiores, o plano Pro inclui 1.000 consultas mensais por R$149. Se o limite for ultrapassado, a API não bloqueia: cobra R$0,15 por consulta adicional.

Como garantir conformidade com a LGPD ao usar uma API de CPF?

Use o CPF apenas para a finalidade declarada ao titular, armazene apenas o necessário (não guarde o CPF cru se um token bastar), implemente controle de acesso aos logs de consulta e documente a base legal para o tratamento. A ANPD orienta que dados de identificação devem ser tratados com o princípio da necessidade.

Quanto tempo leva para integrar a API CPFHub.io?

A integração básica leva menos de 30 minutos: crie uma conta em cpfhub.io, gere a API key no painel e faça uma chamada GET para https://api.cpfhub.io/cpf/{CPF} com o header x-api-key. A documentação inclui exemplos em Python, Node.js, PHP, Java e outras linguagens.

Conclusão

A validação dos dígitos verificadores do CPF é uma operação local, rápida e que pode ser implementada em qualquer linguagem de programação. No entanto, ela garante apenas a integridade matemática do número, não a existência real do documento. Para verificações completas, a combinação com uma API de consulta de dados cadastrais é indispensável.

Cadastre-se em cpfhub.io — 50 consultas mensais gratuitas, sem cartão de crédito — e implemente hoje mesmo a validação completa de CPF com retorno de nome e data de nascimento do titular.