Algoritmo de Luhn: Como Funciona a Validação de Cartão de Crédito

Se você já comprou online, com certeza digitou o número do seu cartão de crédito e, em milissegundos, o sistema identificou se ele era válido ou não, antes mesmo de processar o pagamento. Esse teste rápido de integridade é possível graças ao Algoritmo de Luhn.

Desenvolvido pelo cientista da IBM Hans Peter Luhn em 1954, esse algoritmo (também conhecido como fórmula de módulo 10) é uma fórmula de checksum simples usada para validar uma variedade de números de identificação, como cartões de crédito, IMEI de celulares e até números de previdência social em alguns países.

Neste post, vamos entender a matemática por trás do algoritmo de Luhn, acompanhar um exemplo passo a passo e ver como implementá-lo de forma eficiente em JavaScript e Python.

Como o Algoritmo de Luhn Funciona

O algoritmo verifica se o último dígito do número (chamado de dígito verificador) é matematicamente consistente com os outros dígitos. O processo segue estas três etapas simples:

1. A partir do penúltimo dígito e movendo-se para a esquerda (da direita para a esquerda), multiplique cada segundo dígito por 2.
2. Se o resultado da multiplicação de um dígito for maior que 9 (por exemplo, 2 × 8 = 16), some os dígitos do resultado (ex: 1 + 6 = 7) ou simplesmente subtraia 9 dele (ex: 16 - 9 = 7).
3. Some todos os dígitos do número (tanto os que foram multiplicados quanto os que não foram). Se o total final terminar em 0 (ou seja, for múltiplo de 10), o número é válido de acordo com a fórmula de Luhn.

Exemplo Prático de Validação

Vamos testar o número fictício 49927398716:

Agora somamos todos os dígitos resultantes:

8 + 9 + 9 + 2 + 5 + 3 + 9 + 8 + 5 + 1 + 6 = 70

Como 70 é múltiplo de 10 (70 % 10 === 0), o número é válido.

Implementação em JavaScript

Aqui está uma implementação em JavaScript otimizada para validar strings contendo números de cartões de crédito de qualquer tamanho:

function validarLuhn(numeroCartao) {
  // Remove espaços e traços
  const cleanNumber = String(numeroCartao).replace(/\D/g, '');
  
  if (!cleanNumber || cleanNumber.length < 2) {
    return false;
  }

  let soma = 0;
  let deveDuplicar = false;

  // Percorre o número de trás para frente
  for (let i = cleanNumber.length - 1; i >= 0; i--) {
    let digito = parseInt(cleanNumber.charAt(i), 10);

    if (deveDuplicar) {
      digito *= 2;
      if (digito > 9) {
        digito -= 9;
      }
    }

    soma += digito;
    deveDuplicar = !deveDuplicar;
  }

  return (soma % 10) === 0;
}

// Testando a função
console.log(validarLuhn('49927398716')); // true
console.log(validarLuhn('49927398717')); // false

Implementação em Python

A mesma lógica aplicada em Python, de forma limpa e idiomática:

def validar_luhn(numero_cartao: str) -> bool:
    # Remove qualquer caractere que não seja número
    clean_number = "".join(filter(str.isdigit, str(numero_cartao)))
    
    if len(clean_number) < 2:
        return False
        
    soma = 0
    deve_duplicar = False
    
    # Percorre de trás para frente
    for digito_str in reversed(clean_number):
        digito = int(digito_str)
        
        if deve_duplicar:
            digito *= 2
            if digito > 9:
                digito -= 9
                
        soma += digito
        deve_duplicar = not deve_duplicar
        
    return soma % 10 == 0

# Exemplos de uso
print(validar_luhn("49927398716"))  # True
print(validar_luhn("49927398717"))  # False

Por que Validar o Luhn no Frontend?

A validação do algoritmo de Luhn é uma excelente prática de UX (User Experience). Ao validar o número no lado do cliente (frontend) antes de enviar a requisição de pagamento ao gateway:

• Evitam-se chamadas desnecessárias à API de pagamento, economizando custos de infraestrutura e processamento.
• Dá-se feedback imediato ao usuário caso ele cometa um erro de digitação ao inserir o número do cartão.

Caso precise gerar dados de cartão de crédito válidos e fictícios para testar a sua implementação, utilize o nosso Gerador de Cartão de Crédito.