Como validar CPF em JavaScript, Python e PHP

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

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]);
}

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.

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])

Validar CPF em PHP

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

<?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];
}

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 para criar números válidos de teste e compare o resultado da sua função com o do 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).