Desenvolvedor de Software e Especialista em Tecnologia da Informação

Como validar número de CPF com Javascript 🚀

Você sabia que um CPF consegue descobrir que ele mesmo é falso? Neste artigo, vamos explorar o algoritmo matemático por trás da validação do CPF, entender como os dígitos verificadores funcionam e implementar uma função completa em JavaScript puro. Ideal para quem está aprendendo lógica de programação ou precisa validar CPFs em projetos reais.

📅  3 de junho de 2026
⏱️  9 min
🏷️  Javascript
📚 artigos +

Como validar número de CPF com JavaScript: Guia completo com algoritmo e código

Você sabia que um CPF consegue "descobrir" que ele mesmo é falso? Pode parecer estranho, mas todo CPF possui dois dígitos verificadores que funcionam como uma assinatura matemática. Sempre que um sistema valida um CPF, ele executa uma sequência de cálculos utilizando os nove primeiros números e compara o resultado com os dois últimos dígitos. Se os valores não coincidirem, o documento é considerado inválido.

Validação de CPF JavaScript Puro Algoritmo CPF Dígito Verificador Lógica de Programação Desenvolvimento Web Frontend Backend Validação de Formulários Programação RogerioPontesTI

"O CPF não é apenas um número - é uma assinatura matemática que carrega consigo a capacidade de se validar. Entender esse algoritmo é entender um pouco da beleza escondida nos sistemas que usamos todos os dias."

⭐ DESTAQUE: 🛠️ Gerador de CPF para DEV
Gere CPFs matematicamente válidos para testar seus projetos de software... Saiba mais +

O que é o CPF e por que ele precisa ser validado?

O Cadastro de Pessoas Físicas (CPF) é o documento mais utilizado no Brasil para identificação de cidadãos. Criado pela Receita Federal, o CPF é composto por 11 dígitos que seguem um padrão matemático específico.

A validação do CPF é uma tarefa comum em sistemas de cadastro, formulários web, aplicativos e plataformas que precisam garantir que os dados inseridos pelos usuários são consistentes. Mas por que validar um CPF?

  • Integridade dos dados: Evita que dados incorretos entrem no sistema
  • Experiência do usuário: Feedback imediato sobre a validade do documento
  • Segurança: Uma camada inicial de verificação antes de consultas mais profundas
  • Economia de recursos: Evita chamadas desnecessárias a APIs externas

Neste artigo, vamos construir uma função completa de validação de CPF usando JavaScript puro, entendendo cada etapa do algoritmo e como aplicá-lo em projetos reais.

A estrutura do CPF: entendendo os dígitos

Um CPF válido tem a seguinte estrutura:

ESTRUTURA DO CPF 

// Formato: XXX.XXX.XXX-YY
// Onde:
// - XXX.XXX.XXX = 9 dígitos base
// - YY = 2 dígitos verificadores

// Exemplo: 123.456.789-09
// Base: 123456789
// Dígitos verificadores: 09

Os dois últimos dígitos são chamados de dígitos verificadores. Eles não são aleatórios - são calculados a partir dos nove primeiros dígitos usando um algoritmo matemático específico.

É exatamente esse algoritmo que permite que um sistema "descubra" se um CPF é falso ou verdadeiro, sem precisar consultar a Receita Federal.

O algoritmo de validação do CPF

O algoritmo de validação do CPF é composto por duas etapas principais: o cálculo do primeiro dígito verificador e o cálculo do segundo dígito verificador.

Passo 1: Cálculo do primeiro dígito verificador

Para calcular o primeiro dígito verificador, utilizamos os 9 primeiros dígitos do CPF:

  1. Multiplicamos cada um dos 9 dígitos por uma sequência decrescente de 10 a 2
  2. Somamos todos os resultados
  3. Calculamos o resto da divisão da soma por 11
  4. Subtraímos o resto de 11
  5. Se o resultado for maior que 9, o dígito é 0
CÁLCULO DO PRIMEIRO DÍGITO 

// CPF base: 123456789
// Pesos: 10, 9, 8, 7, 6, 5, 4, 3, 2

// 1*10 + 2*9 + 3*8 + 4*7 + 5*6 + 6*5 + 7*4 + 8*3 + 9*2
// = 10 + 18 + 24 + 28 + 30 + 30 + 28 + 24 + 18
// = 210

// 210 % 11 = 1 (resto da divisão por 11)
// 11 - 1 = 10
// 10 > 9 → dígito = 0

// Primeiro dígito verificador: 0

Passo 2: Cálculo do segundo dígito verificador

Para calcular o segundo dígito verificador, utilizamos os 10 primeiros dígitos (incluindo o primeiro dígito verificador):

  1. Multiplicamos cada um dos 10 dígitos por uma sequência decrescente de 11 a 2
  2. Somamos todos os resultados
  3. Calculamos o resto da divisão da soma por 11
  4. Subtraímos o resto de 11
  5. Se o resultado for maior que 9, o dígito é 0
CÁLCULO DO SEGUNDO DÍGITO 

// CPF com primeiro dígito: 1234567890
// Pesos: 11, 10, 9, 8, 7, 6, 5, 4, 3, 2

// 1*11 + 2*10 + 3*9 + 4*8 + 5*7 + 6*6 + 7*5 + 8*4 + 9*3 + 0*2
// = 11 + 20 + 27 + 32 + 35 + 36 + 35 + 32 + 27 + 0
// = 255

// 255 % 11 = 2 (resto da divisão por 11)
// 11 - 2 = 9

// Segundo dígito verificador: 9

Implementando a validação em JavaScript

Agora que entendemos o algoritmo, vamos implementá-lo em JavaScript. A função completa de validação:

FUNÇÃO COMPLETA DE VALIDAÇÃO 

function validarCPF(cpf) {
    // Remove caracteres não numéricos
    cpf = cpf.replace(/\D/g, "");

    // Verifica se tem 11 dígitos
    if (cpf.length !== 11) {
        return false;
    }

    // Verifica se todos os dígitos são iguais
    if (/^(\d)\1+$/.test(cpf)) {
        return false;
    }

    // Cálculo do primeiro dígito verificador
    let soma = 0;
    for (let i = 0; i < 9; i++) {
        soma += Number(cpf[i]) * (10 - i);
    }

    let primeiroDigito = (soma * 10) % 11;
    if (primeiroDigito === 10) {
        primeiroDigito = 0;
    }

    if (primeiroDigito !== Number(cpf[9])) {
        return false;
    }

    // Cálculo do segundo dígito verificador
    soma = 0;
    for (let i = 0; i < 10; i++) {
        soma += Number(cpf[i]) * (11 - i);
    }

    let segundoDigito = (soma * 10) % 11;
    if (segundoDigito === 10) {
        segundoDigito = 0;
    }

    if (segundoDigito !== Number(cpf[10])) {
        return false;
    }

    return true;
}

Testando a função

TESTANDO A FUNÇÃO 

// CPFs válidos
console.log(validarCPF("123.456.789-09")); // true
console.log(validarCPF("529.982.247-25")); // true

// CPFs inválidos
console.log(validarCPF("111.111.111-11")); // false
console.log(validarCPF("123.456.789-00")); // false

Construindo a interface completa

Agora vamos criar uma interface completa para validar CPF em tempo real:

HTML

HTML 

<!DOCTYPE html>
<html lang="pt-BR">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Validador de CPF</title>
    <link rel="stylesheet" href="./style.css">
    <script src="./main.js" defer></script>
</head>
<body>

    <div class="container">
        <div class="card">
            <h1>Descubra se um CPF é verdadeiro</h1>
            <p>Digite um CPF abaixo:</p>
            <input type="text" id="cpf" 
                   placeholder="000.000.000-00" 
                   oninput="validarCPF(this.value)">
            <div id="resultado">
                Aguardando CPF...</div>
        </div>
    </div>

</body>
</html>

CSS

CSS 

/* style.css */
* {
    margin: 0;
    padding: 0;
    box-sizing: border-box;
}

body {
    font-family: Arial, sans-serif;
    background: #0f172a;
    display: flex;
    justify-content: center;
    align-items: center;
    min-height: 100vh;
    color: #f8fafc;
}

.container {
    width: 100%;
    max-width: 400px;
    padding: 20px;
}

.card {
    background: #1e293b;
    padding: 40px;
    border-radius: 12px;
    text-align: center;
    box-shadow: 0 10px 40px rgba(0,0,0,0.5);
}

h1 {
    font-size: 1.5rem;
    margin-bottom: 12px;
}

p {
    color: #94a3b8;
    margin-bottom: 20px;
}

input {
    width: 100%;
    padding: 14px 16px;
    border-radius: 8px;
    border: 1px solid #334155;
    background: #0f172a;
    color: #f8fafc;
    font-size: 1.1rem;
    text-align: center;
    transition: border 0.3s;
}

input:focus {
    border-color: #38bdf8;
    outline: none;
}

#resultado {
    margin-top: 20px;
    padding: 14px;
    border-radius: 8px;
    background: #0f172a;
    color: #94a3b8;
    font-weight: bold;
    transition: all 0.3s;
}

JavaScript completo

JAVASCRIPT COMPLETO 

/* main.js */

function validarCPF(cpf) {
    const resultado = document.getElementById("resultado");

    // Remove caracteres não numéricos
    cpf = cpf.replace(/\D/g, "");

    // Verifica se tem 11 dígitos
    if (cpf.length < 11) {
        resultado.innerHTML = "Digite um CPF completo";
        resultado.style.background = "#f1f1f1";
        resultado.style.color = "#333";
        return;
    }

    if (cpf.length !== 11) {
        exibirFalso();
        return;
    }

    // Verifica se todos os dígitos são iguais
    if (/^(\d)\1+$/.test(cpf)) {
        exibirFalso();
        return;
    }

    // Cálculo do primeiro dígito verificador
    let soma = 0;
    for (let i = 0; i < 9; i++) {
        soma += Number(cpf[i]) * (10 - i);
    }

    let primeiroDigito = (soma * 10) % 11;
    if (primeiroDigito === 10) {
        primeiroDigito = 0;
    }

    if (primeiroDigito !== Number(cpf[9])) {
        exibirFalso();
        return;
    }

    // Cálculo do segundo dígito verificador
    soma = 0;
    for (let i = 0; i < 10; i++) {
        soma += Number(cpf[i]) * (11 - i);
    }

    let segundoDigito = (soma * 10) % 11;
    if (segundoDigito === 10) {
        segundoDigito = 0;
    }

    if (segundoDigito !== Number(cpf[10])) {
        exibirFalso();
        return;
    }

    resultado.innerHTML = "✅ CPF VERDADEIRO";
    resultado.style.background = "#d1fae5";
    resultado.style.color = "#065f46";
}

function exibirFalso() {
    const resultado = document.getElementById("resultado");
    resultado.innerHTML = "❌ CPF FALSO";
    resultado.style.background = "#fee2e2";
    resultado.style.color = "#991b1b";
}

Melhorias e casos especiais

A função básica já funciona, mas podemos melhorá-la com algumas adições:

Versão otimizada com validação de CPFs conhecidos

VERSÃO OTIMIZADA 

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

    // Validações básicas
    if (cpf.length !== 11) return false;
    if (/^(\d)\1+$/.test(cpf)) return false;

    // Lista de CPFs conhecidos inválidos
    const invalidos = [
        "00000000000",
        "11111111111",
        "22222222222",
        "33333333333",
        "44444444444",
        "55555555555",
        "66666666666",
        "77777777777",
        "88888888888",
        "99999999999"
    ];
    if (invalidos.includes(cpf)) return false;

    // ... resto da validação
    return true;
}

Descubra se um CPF é verdadeiro

Aguardando CPF...

📂 Código Fonte

Todo o código utilizado neste artigo está disponível no GitHub para você baixar, testar e modificar:

GitHub - cpfjs

Conclusão

Validar CPF com JavaScript é um exercício excelente para entender lógica de programação, manipulação de arrays e algoritmos matemáticos. Além disso, é uma habilidade prática que pode ser aplicada em projetos reais imediatamente.

Ao longo deste artigo, você aprendeu:

  • ✅ A estrutura matemática do CPF
  • ✅ Como calcular os dígitos verificadores
  • ✅ Como implementar a validação em JavaScript puro
  • ✅ Como criar uma interface interativa para validação
  • ✅ Boas práticas e melhorias para a função

💡 Lembre-se: A validação matemática é apenas o primeiro passo. Para sistemas críticos, sempre combine a validação de estrutura com verificações adicionais, como consultas a bases de dados oficiais.

🤔 O que você achou?

💬 Quer aprender JavaScript do ZERO? Comece agora a escrever seu primeiro código e seus fundamentos!

❓ FAQ: Perguntas Frequentes sobre sobre Validação de CPF

A validação utiliza um algoritmo matemático baseado nos nove primeiros dígitos para calcular os dois dígitos verificadores. Se os dígitos calculados coincidirem com os dígitos informados, o CPF é considerado válido.

Sim. Todo o algoritmo pode ser implementado utilizando JavaScript puro, sem a necessidade de bibliotecas externas, como demonstrado neste artigo.

Não. A validação matemática apenas verifica se o número possui uma estrutura válida. Para confirmar se o CPF realmente existe e está ativo, é necessário consultar a Receita Federal ou serviços autorizados.

Dependendo do projeto. Para entender a lógica e pequenos sistemas, implementar a função é um excelente exercício. Em projetos grandes, bibliotecas como cpf-cnpj-validator podem economizar tempo e oferecer validações adicionais.

Sim. É um dos usos mais comuns: validar o documento antes do envio ao servidor, melhorando a experiência do usuário e reduzindo chamadas desnecessárias à API.

O código completo está disponível no repositório oficial no GitHub: https://github.com/rogeriopontesti/cpfjs

CPFs como 111.111.111-11 são inválidos porque o algoritmo de validação nunca geraria dígitos verificadores iguais para uma sequência de dígitos repetidos. Eles são usados apenas como exemplos ou para testes.

Cada país possui seu próprio sistema de identificação com algoritmos específicos. O CPF é exclusivo do Brasil. Outros países têm documentos como o SSN (EUA), NIE (Espanha) ou RG (Argentina), cada um com sua própria lógica de validação.

🎬 Assista ao Vídeos completo sobre Refatoração

O vídeo foi feito em Javascript mais o conceito pode ser utilizado em qualquer outra linguagem de programação..

🔗 Conecte-se Comigo

YouTube Site LinkedIn GitHub Instagram

💬 Você já conhecia o algoritmo de validação do CPF? Prefere implementar sua própria função ou utilizar uma biblioteca pronta? Conta aqui nos comentários como você costuma validar CPF nos seus projetos! 👇

#JavaScript #CPF #JavaScriptPuro #Programacao #DesenvolvimentoWeb #Frontend #Backend #LogicaDeProgramacao #Programador #WebDeveloper #Codigo #Tutorial #Dev #PHP #ProjetoWeb