# Como validar CPF em JavaScript, Python e PHP

> Validar um CPF é conferir o formato e recalcular os dois dígitos verificadores com módulo 11. Este guia explica a conta passo a passo e traz funções prontas, testadas, em JavaScript, Python e PHP, além dos erros mais comuns ao guardar e validar CPF.

- Endereço oficial: https://pradev.com.br/guias/como-validar-cpf-em-javascript
- Tipo: Guia
- Publicado em: 2026-09-30
- Atualizado em: 2026-09-30
- Autor: Leonardo Gaertner (https://pradev.com.br/sobre)
- Ferramentas: [Validador de CPF](https://pradev.com.br/validador-de-cpf), [Gerador de CPF](https://pradev.com.br/gerador-de-cpf)

## Como o dígito verificador do CPF é calculado

O CPF tem 11 dígitos: os nove primeiros são o número-base e os dois últimos são dígitos verificadores, calculados a partir dos anteriores. Validar é refazer essa conta e comparar com o que foi digitado.

Para o primeiro dígito, multiplique cada um dos nove dígitos por pesos de 10 a 2, some tudo e divida por 11. Se o resto for menor que 2, o dígito é 0; caso contrário, é 11 menos o resto. O segundo dígito segue a mesma regra, agora com dez dígitos (os nove mais o primeiro dígito verificador) e pesos de 11 a 2.

### Exemplo com 529.982.247-25

- Nove primeiros dígitos: 5 2 9 9 8 2 2 4 7.
- Soma com pesos de 10 a 2: 295. O resto de 295 dividido por 11 é 9, então o primeiro dígito é 11 - 9 = 2.
- Com esse 2 incluído, e pesos de 11 a 2: soma 347. O resto é 6, então o segundo dígito é 11 - 6 = 5.
- Resultado: 529.982.247-25.

O [validador de CPF](https://pradev.com.br/validador-de-cpf) faz exatamente essa conta e mostra o motivo quando o número é recusado.

## Validar CPF em JavaScript

A função abaixo remove a pontuação, recusa tamanhos errados e sequências de dígitos iguais, e recalcula os dois dígitos verificadores.

```javascript
function validarCPF(valor) {
  const cpf = String(valor).replace(/\D/g, '');
  if (cpf.length !== 11) return false;
  if (/^(\d)\1{10}$/.test(cpf)) return false; // 111.111.111-11 e parecidos

  // Pesos de (tamanho + 1) até 2: 10 a 2 no primeiro dígito, 11 a 2 no segundo
  const digito = (base) => {
    let soma = 0;
    for (let i = 0; i < base.length; i++) {
      soma += Number(base[i]) * (base.length + 1 - i);
    }
    const resto = soma % 11;
    return resto < 2 ? 0 : 11 - resto;
  };

  const d1 = digito(cpf.slice(0, 9));
  const d2 = digito(cpf.slice(0, 10));
  return d1 === Number(cpf[9]) && d2 === Number(cpf[10]);
}
```

_JavaScript. Funciona no navegador e no Node.js, sem dependências._

Com ela, `validarCPF('529.982.247-25')` devolve `true` e `validarCPF('529.982.247-24')` devolve `false`.

## Validar CPF em Python

A mesma lógica em Python, usando só a biblioteca padrão.

```python
import re


def validar_cpf(valor: str) -> bool:
    cpf = re.sub(r"\D", "", str(valor))
    if len(cpf) != 11 or cpf == cpf[0] * 11:  # 111.111.111-11 e parecidos
        return False

    def digito(base: str) -> int:
        # Pesos de (tamanho + 1) até 2
        soma = sum(int(d) * (len(base) + 1 - i) for i, d in enumerate(base))
        resto = soma % 11
        return 0 if resto < 2 else 11 - resto

    return digito(cpf[:9]) == int(cpf[9]) and digito(cpf[:10]) == int(cpf[10])
```

_Python_

## Validar CPF em PHP

E em PHP, sem extensões além das que já vêm instaladas.

```php
<?php
function validarCpf(string $valor): bool
{
    $cpf = preg_replace('/\D/', '', $valor);
    if (strlen($cpf) !== 11 || preg_match('/^(\d)\1{10}$/', $cpf)) {
        return false; // tamanho errado ou 111.111.111-11 e parecidos
    }

    // Pesos de (tamanho + 1) até 2
    $digito = function (string $base): int {
        $soma = 0;
        $peso = strlen($base) + 1;
        foreach (str_split($base) as $d) {
            $soma += (int) $d * $peso--;
        }
        $resto = $soma % 11;
        return $resto < 2 ? 0 : 11 - $resto;
    };

    return $digito(substr($cpf, 0, 9)) === (int) $cpf[9]
        && $digito(substr($cpf, 0, 10)) === (int) $cpf[10];
}
```

_PHP_

## Erros comuns ao validar CPF

- Guardar o CPF como número: os zeros à esquerda se perdem (012.345.678-90 vira 12345678890). Guarde como texto de 11 caracteres e aplique a máscara só na exibição.
- Validar só o formato com expressão regular: a regex confere pontos e traços, não os dígitos verificadores. Use a regex para a máscara e a função acima para a validade.
- Esquecer as sequências repetidas: 111.111.111-11 passa no cálculo, mas não é um CPF aceito. As funções deste guia recusam.
- Validar só no navegador: a checagem no front-end ajuda quem digita, mas o servidor precisa validar de novo.
- Tratar CPF válido como CPF existente: os dígitos só provam que o número é coerente, não que foi emitido nem de quem é.
- Registrar o CPF em logs: é dado pessoal, protegido pela LGPD. Evite gravar ou mascare o número.

## Como testar o seu validador

Use o [gerador de CPF](https://pradev.com.br/gerador-de-cpf) para criar números válidos de teste e compare o resultado da sua função com o do [validador de CPF](https://pradev.com.br/validador-de-cpf). Os números gerados nunca foram emitidos, mas podem coincidir por acaso com o de uma pessoa real, então use só em testes de software.

Casos que toda função de validação deve acertar:

- Válidos: 529.982.247-25 e 111.444.777-35.
- Inválidos: 529.982.247-24 (dígito errado), 111.111.111-11 (sequência repetida) e 123 (tamanho errado).

## Perguntas frequentes

### Validar CPF com regex funciona?

Só para o formato. Uma expressão regular confere se há 11 dígitos, com ou sem pontuação, mas não consegue recalcular os dígitos verificadores. Combine a regex, para a máscara, com uma função de cálculo, para a validade.

### Um CPF válido é um CPF real?

Não necessariamente. Válido quer dizer que os dois dígitos finais batem com o cálculo. Isso não prova que o CPF foi emitido pela Receita Federal nem a quem pertence.

### O que fazer com um CPF digitado com pontos e traço?

Remova tudo que não for dígito antes de validar, como as funções deste guia fazem, e guarde só os números. Aplique a máscara apenas na hora de exibir.

### Por que 111.111.111-11 é recusado se o cálculo bate?

Porque sequências de dígitos iguais passam no cálculo, mas são rejeitadas pela maioria dos sistemas e não são usadas como CPF. Recusar essas sequências deixa a validação mais útil.

## Fontes

- [Cadastro de Pessoas Físicas (Wikipédia)](https://pt.wikipedia.org/wiki/Cadastro_de_Pessoas_F%C3%ADsicas)

## Guias relacionados

- [CNPJ alfanumérico: o que muda e como validar em código](https://pradev.com.br/guias/cnpj-alfanumerico-como-validar): Entenda o CNPJ alfanumérico (letras e números), o que muda para quem desenvolve e veja funções testadas para validar em JavaScript, Python e PHP.