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

> Aprenda o algoritmo de validação dos dígitos verificadores do CPF com exemplos em Python, JavaScript, Go e PHP. Combine com API para validação real.

**Publicado:** 21/08/2024
**Autor:** Redação CPFHub.io
**URL:** https://cpfhub.io/blog/como-fazer-validacao-de-digitos-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

```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

```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

```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
<?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:

```python
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](https://www.gov.br/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.

### Leia também

- [Diferença entre validação de CPF e consulta de CPF: quando usar cada uma](https://cpfhub.io/blog/diferenca-entre-validacao-de-cpf-e-consulta-de-cpf-quando-usar-cada-uma)
- [API de CPF grátis para desenvolvedores: como começar em 5 minutos](https://cpfhub.io/blog/api-cpf-gratis-desenvolvedores-comecar-5-minutos)
- [Como consultar CPF na Receita Federal pelo site oficial](https://cpfhub.io/blog/como-consultar-cpf-na-receita-federal-pelo-site-oficial)
- [APIs de CPF: como avaliar o custo-benefício antes de contratar?](https://cpfhub.io/blog/apis-de-cpf-como-avaliar-o-custo-beneficio-antes-de-contratar)

---

## 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](https://www.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.