Como Funciona o Cálculo do Módulo 11 (CPF e CNPJ Passo a Passo)

No ecossistema de desenvolvimento de software no Brasil, poucas rotinas de validação são tão frequentes e essenciais quanto a checagem de CPF (Cadastro de Pessoas Físicas) e CNPJ (Cadastro Nacional da Pessoa Jurídica). Seja em um formulário de checkout em e-commerce, na abertura de contas digitais em fintechs ou na integração com sistemas ERP, validar a consistência cadastral antes de chamar uma API externa economiza requisições desnecessárias e impede a entrada de dados corrompidos no banco de dados.

Ambos os documentos utilizam uma variação da técnica matemática de soma ponderada conhecida como Módulo 11 para gerar seus dois últimos algarismos: os famosos dígitos verificadores (DV). Neste guia aprofundado, você entenderá exatamente como essa matemática funciona e como implementá-la em código limpo.

1. Anatomia do Cadastro de Pessoa Física (CPF)

O CPF é estruturado por exatamente 11 algarismos decimais no formato tradicional XXX.XXX.XXX-YY:

• 8 primeiros dígitos (Base Cadastral): Identificam o registro individual do cidadão na base da Receita Federal.
• 9º dígito (Região Fiscal de Origem): Identifica a Unidade Federativa onde o CPF foi emitido originalmente.
• 2 últimos dígitos (Dígitos Verificadores): Calculados matematicamente pelos pesos do Módulo 11 sobre os 9 dígitos anteriores.

2. O Passo a Passo Matemático do Cálculo do CPF

Passo 1: Primeiro Dígito Verificador (DV1)

Para encontrar o 10º algarismo, multiplicamos cada um dos 9 primeiros dígitos por uma série decrescente de pesos inteiros que se inicia em 10 e termina em 2:

Soma = (D1 * 10) + (D2 * 9) + (D3 * 8) + (D4 * 7) + (D5 * 6) + 
       (D6 * 5) + (D7 * 4) + (D8 * 3) + (D9 * 2)

Resto = Soma % 11

Se Resto < 2:
    DV1 = 0
Senão:
    DV1 = 11 - Resto
        

Passo 2: Segundo Dígito Verificador (DV2)

Agora incluímos o DV1 recém-calculado na sequência de dígitos (totalizando 10 algarismos) e aplicamos nova multiplicação ponderada, desta vez começando com o peso 11 até 2:

Soma = (D1 * 11) + (D2 * 10) + (D3 * 9) + ... + (D9 * 3) + (DV1 * 2)

Resto = Soma % 11

Se Resto < 2:
    DV2 = 0
Senão:
    DV2 = 11 - Resto
        

3. O Caso Crítico dos Dígitos Repetidos

Um erro de implementação clássico em bibliotecas de validação é esquecer o caso de CPFs com dígitos repetidos, como 111.111.111-11, 000.000.000-00 ou 999.999.999-99.

Matematicamente, sequências repetidas satisfazem a fórmula do Módulo 11! Por isso, a Receita Federal do Brasil classifica explicitamente todos os 11 números formados pelo mesmo caractere como inválidos por convenção. Qualquer validador deve checar essa condição antes de iniciar as somas ponderadas:

if (/^(\d)\1{10}$/.test(cpfLimpo)) {
    return false; // Rejeita 00000000000, 11111111111, etc.
}
        

4. Como Funciona no CNPJ (Cadastro Nacional da Pessoa Jurídica)

O CNPJ possui 14 dígitos (XX.XXX.XXX/YYYY-ZZ). A diferença fundamental em relação ao CPF está na distribuição dos pesos: como o CNPJ tem mais dígitos, os pesos variam de 2 a 9 de forma cíclica!

• Para o 1º DV (13º dígito): Multiplica-se os 12 primeiros números pelos pesos [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2].
• Para o 2º DV (14º dígito): Multiplica-se os 13 números (incluindo o DV1) pelos pesos [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2].

A regra de resolução do resto é idêntica: Resto = Soma % 11; se Resto < 2 o dígito é 0, caso contrário é 11 - Resto.

5. Implementação de Referência em JavaScript Moderno

Abaixo está uma função otimizada e testada para uso em produção no Node.js ou navegador:

function validarCPF(cpf) {
  if (typeof cpf !== 'string') return false;
  const limpo = cpf.replace(/\D/g, '');
  
  if (limpo.length !== 11) return false;
  if (/^(\d)\1{10}$/.test(limpo)) return false;

  // Cálculo do 1º Dígito Verificador
  let soma = 0;
  for (let i = 0; i < 9; i++) {
    soma += parseInt(limpo.charAt(i), 10) * (10 - i);
  }
  let resto = soma % 11;
  const dv1 = resto < 2 ? 0 : 11 - resto;
  if (dv1 !== parseInt(limpo.charAt(9), 10)) return false;

  // Cálculo do 2º Dígito Verificador
  soma = 0;
  for (let i = 0; i < 10; i++) {
    soma += parseInt(limpo.charAt(i), 10) * (11 - i);
  }
  resto = soma % 11;
  const dv2 = resto < 2 ? 0 : 11 - resto;
  return dv2 === parseInt(limpo.charAt(10), 10);
}
        

Perguntas Frequentes sobre o Algoritmo (FAQ)