Como validar um CPF com JavaScript

Validar CPF no front-end ajuda a evitar erros em formulários de cadastro, checkout e login. No back-end, a validação é uma segunda barreira contra dados digitados incorretamente e fraudes mais básicas.

Neste artigo, você vai entender o algoritmo do CPF e implementar uma função de validação de CPF em JavaScript puro, sem biblioteca externa.

O que são os dígitos verificadores

Um CPF tem 11 dígitos:

Os 9 primeiros são a base do documento.
Os 2 últimos são os dígitos verificadores.

Esses dois dígitos são calculados a partir dos anteriores. A ideia é detectar erros comuns de digitação, como trocar ou remover um número.

A validação matemática, porém, não confirma se o CPF existe, pertence a determinada pessoa ou está regular na Receita Federal. Ela apenas verifica se os dígitos obedecem ao algoritmo do CPF.

Primeiro dígito verificador

Considere o CPF sem formatação:

52998224725

Os 9 primeiros dígitos são:

5 2 9 9 8 2 2 4 7

Multiplicamos cada número pelos pesos de 10 a 2:

5×10 + 2×9 + 9×8 + 9×7 + 8×6 + 2×5 + 2×4 + 4×3 + 7×2

O resultado é:

50 + 18 + 72 + 63 + 48 + 10 + 8 + 12 + 14 = 295

Agora calculamos o resto da divisão por 11:

295 % 11 = 9

Como o resto é maior que 1, fazemos:

11 - 9 = 2

Portanto, o primeiro dígito verificador é 2.

Segundo dígito verificador

Agora usamos os 10 primeiros dígitos, incluindo o verificador calculado:

5 2 9 9 8 2 2 4 7 2

Aplicamos os pesos de 11 a 2:

5×11 + 2×10 + 9×9 + 9×8 + 8×7 + 2×6 + 2×5 + 4×4 + 7×3 + 2×2

A soma fica:

55 + 20 + 81 + 72 + 56 + 12 + 10 + 16 + 21 + 4 = 347

O resto da divisão por 11 é:

347 % 11 = 6

Como o resto é maior que 1:

11 - 6 = 5

O segundo dígito verificador é 5. Assim, o CPF completo é:

52998224725

Esse é o algoritmo do CPF: calcular o primeiro dígito, incorporá-lo à sequência e calcular o segundo.

Implementação em JavaScript puro

A função precisa lidar com entradas formatadas, como 529.982.247-25, e também com uma sequência de números sem pontuação.

Uma implementação possível é esta:

function validarCPF(cpf) {
  // Garante que a entrada seja tratada como texto
  cpf = String(cpf).replace(/\D/g, "");

  // Um CPF válido deve ter exatamente 11 dígitos
  if (cpf.length !== 11) {
    return false;
  }

  // Rejeita CPFs formados pelo mesmo dígito
  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 += Number(cpf[i]) * (10 - i);
  }

  let resto = soma % 11;
  const primeiroDigito = resto < 2 ? 0 : 11 - resto;

  // O primeiro dígito calculado deve ser igual ao informado
  if (primeiroDigito !== Number(cpf[9])) {
    return false;
  }

  // Calcula o segundo dígito verificador
  soma = 0;

  for (let i = 0; i < 10; i++) {
    soma += Number(cpf[i]) * (11 - i);
  }

  resto = soma % 11;
  const segundoDigito = resto < 2 ? 0 : 11 - resto;

  // O segundo dígito calculado também deve ser igual ao informado
  return segundoDigito === Number(cpf[10]);
}

Exemplos de uso:

console.log(validarCPF("529.982.247-25"));
// true

console.log(validarCPF("52998224725"));
// true

console.log(validarCPF("529.982.247-26"));
// false

console.log(validarCPF("111.111.111-11"));
// false

O trecho replace(/\D/g, '') remove tudo que não for dígito. Isso permite aceitar tanto 529.982.247-25 quanto 52998224725.

A expressão regular usada para dígitos repetidos merece atenção:

/^(\d)\1{10}$/;

Ela identifica uma sequência de 11 caracteres formada pelo mesmo dígito. Isso impede que valores como 111.111.111-11 sejam aceitos.

Esse é um detalhe que costuma pegar quem já bateu cabeça com o problema: CPFs com todos os dígitos iguais passam pela conta matemática, mas devem ser rejeitados explicitamente. Se você implementar apenas os cálculos, 11111111111 será considerado válido pelo seu código.

Se quiser testar entradas rapidamente sem criar um formulário, use nosso validador de CPF online, gratuito.

Validação no formulário

Você pode chamar a função no evento de envio do formulário:

const formulario = document.querySelector("#formulario");
const campoCPF = document.querySelector("#cpf");
const mensagem = document.querySelector("#mensagem");

formulario.addEventListener("submit", function (evento) {
  evento.preventDefault();

  if (!validarCPF(campoCPF.value)) {
    mensagem.textContent = "Informe um CPF válido.";
    return;
  }

  mensagem.textContent = "CPF válido.";
});

Essa validação melhora a experiência no navegador, mas não substitui a validação no servidor. Qualquer código executado no front-end pode ser alterado ou ignorado pelo cliente. O back-end deve repetir a validação antes de salvar ou processar o dado.

Erros comuns

Validar CPF só com regex de formato

Uma expressão como esta:

/^\d{3}\.\d{3}\.\d{3}-\d{2}$/;

verifica apenas se o texto tem o formato 000.000.000-00. Ela não calcula os dígitos verificadores.

Por exemplo, 123.456.789-00 pode estar perfeitamente formatado e ainda assim ser um CPF inválido. Regex pode ajudar a conferir a aparência da entrada, mas não substitui o algoritmo do CPF.

Esquecer os zeros à esquerda

CPF é identificador, não número para fazer operações matemáticas comuns. Por isso, trate-o como string.

Se você converter um CPF para Number, um valor com zero inicial pode perder esse zero:

const cpf = Number("012.345.678-90");

Além disso, números muito grandes não devem ser usados como representação principal de documentos. A função deste artigo converte a entrada para texto com String(cpf) e remove a formatação antes de calcular.

Na prática, prefira manter o valor vindo do campo HTML como string desde o início.

Não normalizar a entrada

Se o código espera exatamente 11 dígitos, ele pode rejeitar um CPF formatado antes mesmo de fazer o cálculo.

Esta etapa resolve o problema:

cpf = String(cpf).replace(/\D/g, "");

Ela remove pontos, traços, espaços e outros caracteres não numéricos. Depois disso, a função verifica se sobraram exatamente 11 dígitos.

Validar apenas no navegador

A validação no front-end é útil para dar retorno imediato, mas não é uma camada de segurança. Um usuário pode fazer uma requisição diretamente ao servidor sem passar pelo JavaScript da página.

A mesma regra deve existir no back-end, de preferência em uma função centralizada e coberta por testes.

Perguntas frequentes

Como saber se um CPF é válido?

Primeiro, remova pontos e traço e confirme que restaram 11 dígitos. Depois, rejeite sequências com todos os dígitos iguais e calcule os dois dígitos verificadores conforme o algoritmo do CPF.

O CPF só será matematicamente válido se os dois dígitos calculados forem iguais aos dois últimos dígitos informados. A função validarCPF(cpf) apresentada neste artigo executa todas essas etapas.

Isso não significa que o documento esteja ativo, regular ou associado a uma pessoa específica. Significa apenas que ele passa pela validação matemática.

Como calcular o dígito verificador do CPF?

Para o primeiro dígito, multiplique os 9 dígitos base pelos pesos de 10 a 2. Some os resultados e calcule o resto da divisão por 11.

Se o resto for 0 ou 1, o dígito será 0.
Caso contrário, o dígito será 11 - resto.

Para o segundo dígito, faça a mesma operação usando os 10 primeiros dígitos e os pesos de 11 a 2.

Em JavaScript, a parte central do cálculo pode ser escrita assim:

const digito = resto < 2 ? 0 : 11 - resto;

Validar CPF é a mesma coisa que consultar na Receita Federal?

Não. A validação matemática é uma verificação local: o sistema calcula os dígitos e compara o resultado com o CPF informado.

Uma consulta oficial é outra operação. Ela pode verificar informações cadastrais e a situação do CPF em uma base oficial, normalmente por meio de um serviço autorizado ou dos canais disponibilizados pela Receita Federal.

Portanto, um CPF pode passar pelo algoritmo e ainda não estar regular, não existir no cadastro consultado ou não pertencer à pessoa que o informou. O código JavaScript não confirma identidade nem situação cadastral.