Como funciona o dígito verificador do CPF: o algoritmo explicado

O CPF (Cadastro de Pessoas Físicas) é o principal documento de identificação do cidadão brasileiro, e sua integridade depende de um mecanismo matemático simples, mas eficaz: os dígitos verificadores. Esses dois últimos números do CPF não são aleatórios — eles são calculados a partir dos nove primeiros dígitos através de um algoritmo de módulo 11, garantindo que erros de digitação, transposição ou digitação sequencial sejam detectados automaticamente. A API SmartCPF utiliza essa mesma validação matemática como primeira camada de verificação antes de consultar bases de dados oficiais, eliminando consultas desnecessárias e reduzindo custos operacionais.

Quando um sistema recebe um CPF para cadastro ou consulta, validar os dígitos verificadores localmente é o passo mais barato e rápido para rejeitar entradas inválidas. No entanto, a validação matemática sozinha não garante que o CPF existe, está ativo ou pertence à pessoa que o informa — para isso, é necessário consultar a Receita Federal ou bureaus de crédito. A SmartCPF combina a validação algorítmica imediata com a consulta em tempo real, retornando não apenas a validade formal, mas também situação cadastral, dados cadastrais e métricas de risco em uma única requisição.

O algoritmo do módulo 11 aplicado ao CPF

O cálculo dos dígitos verificadores do CPF segue o algoritmo do módulo 11 (ISBN-10), amplamente utilizado em documentos de identificação no mundo todo. Para o primeiro dígito verificador (10ª posição), multiplica-se cada um dos nove primeiros dígitos por pesos decrescentes de 10 a 2, soma-se os produtos, calcula-se o resto da divisão por 11, e o dígito é 11 menos esse resto (se o resultado for 10 ou 11, o dígito vira 0). Para o segundo dígito verificador (11ª posição), o processo é idêntico, mas inclui o primeiro dígito verificador no cálculo e usa pesos de 11 a 2. Matematicamente:

• Dígito 1 (DV1): DV1 = (11 - (Σ(dᵢ × (11-i)) mod 11)) mod 11, para i = 1 a 9
• Dígito 2 (DV2): DV2 = (11 - (Σ(dᵢ × (12-i)) mod 11)) mod 11, para i = 1 a 10 (incluindo DV1)

Se qualquer um dos dois dígitos calculados não conferir com o informado, o CPF é inválido. Esse algoritmo detecta 100% dos erros de um único dígito e a grande maioria dos erros de transposição de dígitos adjacentes.

Vantagens da validação algorítmica

1. Custo zero de infraestrutura
A validação roda localmente, sem chamadas de rede, bancos de dados ou APIs externas — ideal para formulários frontend, validação em lote ou pré-filtro em pipelines de dados.

2. Latência imperceptível
O cálculo executa em microssegundos, mesmo para milhões de CPFs, permitindo validação em tempo real durante a digitação (onblur, onchange) sem degradar a experiência do usuário.

3. Detecção imediata de erros de digitação
Erros como dígito trocado, omitido ou duplicado são capturados antes de qualquer consulta paga, economizando créditos de API e reduzindo ruído em logs de auditoria.

4. Independência de disponibilidade externa
Funciona offline, em ambientes air-gapped ou durante janelas de manutenção de serviços terceiros — a validação matemática nunca "cai".

5. Base para geração de CPFs de teste
Conhecendo o algoritmo, equipes de QA podem gerar CPFs sintáticos válidos para testes automatizados sem consumir dados reais ou créditos de consulta.

6. Padronização universal
O módulo 11 é um padrão conhecido (ISO 7064), documentado e implementável em qualquer linguagem sem dependências externas.

Limitações da validação apenas algorítmica

1. Não confirma existência na Receita Federal
Um CPF matematicamente válido pode não estar cadastrado, estar cancelado, suspenso ou pertencer a outra pessoa — a validação só garante a sintaxe.

2. Não detecta fraude de identidade
Golpistas podem gerar CPFs válidos algoritmicamente e usá-los em cadastros; apenas a consulta oficial revela se o documento pertence ao titular alegado.

3. Não informa situação cadastral
Status como "Regular", "Pendente de regularização", "Suspenso", "Cancelado" ou "Nulo" só estão disponíveis via consulta à base da RFB ou bureaus autorizados.

4. Vulnerável a CPFs de testes conhecidos
Sequências como 111.111.111-11, 222.222.222-22 etc. passam na validação matemática, mas são CPFs inválidos para uso real — exigem lista de bloqueio adicional.

5. Não substitui validação de documentos complementares
Para KYC completo, o CPF válido é apenas o ponto de partida; RG, CNH, comprovante de residência e biometria formam o conjunto probatório.

Como implementar a validação completa com a SmartCPF

A abordagem recomendada combina validação local (módulo 11) como pré-filtro gratuito e a API SmartCPF para verificação oficial, situação cadastral e enriquecimento de dados. O exemplo abaixo demonstra esse fluxo: valida o CPF localmente, e se passar, consulta a API com o header X-API-KEY obrigatório, tratando erros de rede, autenticação e limites de crédito.

/**
 * Valida CPF usando algoritmo módulo 11 (validação local, custo zero)
 * @param {string} cpf - CPF apenas números (11 dígitos)
 * @returns {boolean} true se dígitos verificadores conferem
 */
function validarCPFLocal(cpf) {
  // Remove formatação
  const numeros = cpf.replace(/\D/g, '');
  
  // Verifica comprimento e sequências inválidas (ex: 111.111.111-11)
  if (numeros.length !== 11 || /^(\d)\1{10}$/.test(numeros)) {
    return false;
  }

  // Calcula primeiro dígito verificador (pesos 10 a 2)
  let soma = 0;
  for (let i = 0; i < 9; i++) {
    soma += parseInt(numeros[i]) * (10 - i);
  }
  let dv1 = 11 - (soma % 11);
  dv1 = dv1 >= 10 ? 0 : dv1;

  // Calcula segundo dígito verificador (pesos 11 a 2, inclui DV1)
  soma = 0;
  for (let i = 0; i < 10; i++) {
    soma += parseInt(numeros[i]) * (11 - i);
  }
  let dv2 = 11 - (soma % 11);
  dv2 = dv2 >= 10 ? 0 : dv2;

  return dv1 === parseInt(numeros[9]) && dv2 === parseInt(numeros[10]);
}

/**
 * Consulta CPF na API SmartCPF com autenticação X-API-KEY
 * @param {string} cpf - CPF formatado ou apenas números
 * @param {string} apiKey - Sua chave da SmartCPF
 * @param {string} [pacote='basic'] - Pacote de consulta (basic, complete, etc.)
 * @returns {Promise<Object>} Resposta da API parseada
 */
async function consultarSmartCPF(cpf, apiKey, pacote = 'basic') {
  const cpfLimpo = cpf.replace(/\D/g, '');
  
  // Pré-validação local: evita gastar crédito com CPF inválido
  if (!validarCPFLocal(cpfLimpo)) {
    throw new Error('CPF inválido (dígitos verificadores não conferem)');
  }

  const url = `https://api.smartcpf.com.br/v2/individuals/${cpfLimpo}?package=${pacote}`;
  
  try {
    const response = await fetch(url, {
      method: 'GET',
      headers: {
        'X-API-KEY': apiKey,        // Header obrigatório — nunca use Authorization Bearer
        'Accept': 'application/json',
        'Content-Type': 'application/json'
      }
    });

    const data = await response.json();

    // Tratamento de erros HTTP e de negócio
    if (!response.ok) {
      const erro = data.errors?.[0]?.message || `Erro HTTP ${response.status}`;
      throw new Error(`SmartCPF: ${erro}`);
    }

    if (!data.success) {
      throw new Error(`SmartCPF: ${data.errors?.[0]?.message || 'Consulta mal-sucedida'}`);
    }

    return data;
  } catch (err) {
    // Erro de rede, timeout, DNS, etc.
    if (err instanceof TypeError && err.message.includes('fetch')) {
      throw new Error('Falha de conexão com a API SmartCPF — verifique rede e DNS');
    }
    throw err; // Re-lança erros de negócio já formatados
  }
}

// Exemplo de uso completo
async function exemploUso() {
  const MINHA_API_KEY = 'sk_live_sua_chave_aqui'; // Substitua pela sua chave real
  const cpfTeste = '111.111.111-11'; // CPF de exemplo — substitua pelo real

  try {
    console.log('1. Validando localmente...');
    if (!validarCPFLocal(cpfTeste)) {
      console.log('CPF rejeitado na validação local — dígitos inválidos');
      return;
    }
    console.log('✓ CPF válido matematicamente');

    console.log('2. Consultando SmartCPF...');
    const resultado = await consultarSmartCPF(cpfTeste, MINHA_API_KEY, 'complete');
    
    console.log('✓ Consulta realizada com sucesso');
    console.log(`   ConsultId: ${resultado.meta.consultId}`);
    console.log(`   Saldo restante: ${resultado.meta.balance} créditos`);
    console.log(`   Situação: ${resultado.result.status}`);
    console.log(`   Nome: ${resultado.result.name}`);
    console.log(`   Idade: ${resultado.result.age} anos`);
    
    // Acesso a dados enriquecidos do pacote 'complete'
    if (resultado.result.emails?.length) {
      console.log(`   E-mails: ${resultado.result.emails.join(', ')}`);
    }
    if (resultado.result.phones?.length) {
      console.log(`   Telefones: ${resultado.result.phones.map(p => p.number).join(', ')}`);
    }
  } catch (err) {
    console.error('Erro:', err.message);
  }
}

exemploUso();

Resposta da API

{
  "meta": {
    "searchType": "CPF G",
    "consultId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "user": "Desenvolvedor Teste",
    "message": "CPF encontrado com sucesso",
    "ip": "127.0.0.1",
    "success": true,
    "apiVersion": "v2",
    "date": "2026-08-18T14:32:15.123Z",
    "executionTimeMs": 74.1,
    "balance": 9.77
  },
  "result": {
    "cpf": "111.111.111-11",
    "name": "João da Silva",
    "birthDate": "10/09/1992",
    "age": 33,
    "motherName": "Maria da Silva",
    "gender": "M",
    "status": "Regular",
    "emails": ["[email protected]"],
    "phones": [
      {
        "number": "(55) 99999-9999",
        "blockedTelemarketing": false,
        "operator": "VIVO",
        "type": "CELULAR",
        "whatsapp": false
      }
    ],
    "addresses": []
  },
  "success": true,
  "errors": []
}

O fluxo demonstrado resolve na prática:

• Pré-validação gratuita elimina consultas pagas para CPFs com dígitos incorretos (typos, sequências inválidas)
• consultId (ex: a1b2c3d4...) permite rastreamento e auditoria de cada consulta nos logs da SmartCPF
• balance (ex: 9.77) mostra créditos restantes em tempo real, evitando surpresas de quota esgotada
• status (Regular, Pendente, Suspenso, Cancelado, Nulo) define regras de negócio automáticas (aprovar, bloquear, solicitar regularização)
• executionTimeMs (ex: 74.1) monitora latência da integração para SLA interno
• Dados enriquecidos (emails, phones, addresses) no pacote complete alimentam CRM, scoring de risco e comunicações sem consultas adicionais

Por que usar a SmartCPF para validação de CPF

Resposta sub-100ms em 99% das requisições — infraestrutura otimizada com cache inteligente e conexão direta às bases oficiais, sem proxies intermediários que adicionam latência.

Integração via HTTP puro com header X-API-KEY — sem SDKs obrigatórios, OAuth flows complexos ou geração de tokens temporários; funciona em qualquer linguagem, serverless, edge functions ou até frontend (via proxy).

Modelo de créditos pré-pagos sem expiração — pague apenas pelo que consumir, sem assinatura mensal, fidelidade ou renovação automática; créditos não usados permanecem válidos indefinidamente.

Escalabilidade horizontal nativa — a API suporta picos de milhares de req/s sem throttling agressivo; limites suaves baseados no saldo, não em janelas de tempo fixas.

Dados oficiais atualizados em tempo real — sincronização contínua com Receita Federal, bureaus de crédito e fontes públicas, garantindo que status, name e birthDate reflitam a situação atual, não snapshots mensais.

Conclusão

O dígito verificador do CPF é uma camada necessária, mas insuficiente: garante sintaxe, não identidade. Combinar a validação local do módulo 11 (custo zero, latência zero) com a consulta oficial via SmartCPF (dados autoritários, enriquecimento, auditoria) entrega o melhor equilíbrio entre performance, custo e confiabilidade para qualquer sistema que processe CPFs no Brasil. Crie sua conta na SmartCPF e faça sua primeira consulta em minutos.