Fundamentos técnicos

Algoritmo de Luhn: qué es y cómo funciona para validar tarjetas de crédito

Publicado: 2026-09-29  ·  10 min de lectura

El algoritmo de Luhn es una fórmula de suma de comprobación (checksum) que permite verificar si un número de tarjeta de crédito está bien escrito: se aplica a los 16 dígitos, hace una suma con duplicaciones selectivas y comprueba si el total es divisible entre 10.

Puntos clave

• El algoritmo de Luhn (o "módulo 10") es un checksum, no una verificación de que la tarjeta exista.
• Lo creó Hans Peter Luhn en IBM, en 1954, y hoy es un estándar de facto en tarjetas, IMEI y códigos EAN/UPC.
• Funciona con 5 pasos: invertir, duplicar posiciones alternas, sumar dígitos, sumar todo y comprobar el módulo 10.
• Puedes calcular el dígito de control (el último) para que cualquier prefijo se vuelva válido.
• Se implementa en pocas líneas de JavaScript, Python o PHP, sin dependencias externas.

Si el resultado es múltiplo de 10, el número es "válido" según Luhn; si no, hay un error de tecleo. Eso es todo lo que hace: detecta errores, no confirma que una tarjeta exista. Un número puede pasar Luhn y no pertenecer a ninguna cuenta real. Por eso es la base de los generadores de tarjetas de prueba y de la mayoría de los validadores que usan los desarrolladores.

En esta guía vas a entender qué es el algoritmo de Luhn, cómo funciona paso a paso, cómo se calcula el dígito de control y cómo implementarlo en JavaScript, Python y PHP. También verás qué detecta y qué no, y por qué es tan útil cuando pruebas software de pagos.

Qué es el algoritmo de Luhn y de dónde viene

El algoritmo de Luhn, también llamado fórmula de Luhn o módulo 10, es un método sencillo para validar números de identificación. Su objetivo es detectar dos tipos de errores muy frecuentes al escribir a mano:

• Un dígito mal tecleado (por ejemplo, escribir 4 en lugar de 5).
• Un intercambio de dos dígitos adyacentes (por ejemplo, escribir 67 en lugar de 76).

Lo diseñó Hans Peter Luhn, un ingeniero alemán que trabajó en IBM y llegó a registrar más de 80 patentes. Presentó el método en 1954, y la compañía lo popularizó primero para validar números de tarjetas de crédito. Con el tiempo, organismos como la ISO lo adoptaron y hoy aparece en prácticamente todos los sistemas que necesitan comprobar un número largo sin consultar una base de datos.

La gran ventaja de Luhn es que no necesita internet ni una lista de tarjetas. Es puro cálculo matemático: se ejecuta en microsegundos, en cualquier lenguaje y en cualquier dispositivo. Por eso las pasarelas lo usan como primer filtro antes de hacer una comprobación real contra el emisor.

Luhn no es exclusivo de las tarjetas

Aunque lo asociemos con tarjetas de crédito, el algoritmo se aplica a muchos identificadores numéricos:

• IMEI de teléfonos móviles (15 dígitos).
• EAN-13, UPC-A y otros códigos de barras de productos.
• Números de cuenta en algunos sistemas bancarios.
• Números de Seguro Social en ciertos países y otros documentos oficiales.

Ese detalle es importante: si ves que un IMEI pasa Luhn, no significa que el teléfono exista; solo que el número está bien formado.

Cómo funciona el algoritmo de Luhn paso a paso

El algoritmo de Luhn trabaja sobre los dígitos de derecha a izquierda. Estos son los 5 pasos:

1. Anota el número y cuenta desde la derecha. El último dígito (el de la derecha) es el dígito de control.
2. Duplica un dígito sí y otro no. Empezando por el segundo dígito desde la derecha, duplica el valor de cada dígito en posición alterna.
3. Reduce los resultados de dos cifras. Si al duplicar obtienes un número de dos dígitos (por ejemplo, 8 × 2 = 16), súmalos entre sí (1 + 6 = 7). Esto equivale a restar 9 al resultado.
4. Suma todos los dígitos. Incluye tanto los que duplicaste como los que no.
5. Comprueba el módulo 10. Si la suma total es divisible entre 10, el número es válido según Luhn.

Un detalle que confunde a mucha gente: el dígito de control no se duplica. Solo se duplican las posiciones alternas a partir del segundo dígito contando desde la derecha.

Ejemplo práctico con el número 4539 1488 0343 6467

Vamos a validar un número clásico de prueba, el 4539 1488 0343 6467, que empieza por 4 (prefijo de Visa). Colocamos los dígitos y aplicamos los pasos:

Ahora sumamos todos los valores de la última fila:

8 + 5 + 6 + 9 + 2 + 4 + 7 + 8 + 0 + 3 + 8 + 3 + 3 + 4 + 3 + 7 = 80

Como 80 es divisible entre 10, el número 4539 1488 0343 6467 es válido según el algoritmo de Luhn. Si te hubieras equivocado al teclear un solo dígito, la suma no habría dado múltiplo de 10 y el algoritmo lo habría detectado.

¿Quieres comprobarlo tú mismo sin hacer las cuentas? Pega cualquier número en nuestro validador de tarjetas de crédito y te dirá al instante si pasa Luhn, además de detectar su tipo y su BIN.

Cómo generar el dígito de control (checksum)

Validar es útil, pero a veces lo que necesitas es lo contrario: partir de un prefijo y calcular el último dígito para que el número completo sea válido. Esto es exactamente lo que hace un generador de tarjetas de prueba.

El procedimiento es el inverso al de validación:

1. Toma el número sin el último dígito (el prefijo que ya tienes).
2. Aplica los pasos 2 y 3 del algoritmo de Luhn (duplicar posiciones alternas desde la derecha) sobre esos dígitos.
3. Suma todos los valores.
4. Calcula el resto de esa suma módulo 10.
5. El dígito de control es (10 − resto) módulo 10.

Si el resto es 0, el dígito de control es 0. En cualquier otro caso, es la diferencia hasta el siguiente múltiplo de 10.

Por ejemplo, si tras sumar te queda un total de 76, el resto módulo 10 es 6 y el dígito de control será 10 − 6 = 4. Con ese 4 al final, la suma total sería 80, divisible entre 10.

Este truco es el corazón de herramientas como nuestro generador de tarjetas de crédito: combina un BIN real, genera dígitos aleatorios y calcula el checksum para que cada número pase Luhn.

Cómo implementar el algoritmo de Luhn en código

La mejor parte del algoritmo es lo corto que es. Aquí tienes tres implementaciones listas para copiar en tus pruebas.

JavaScript

function luhnValido(numero) {
  // Quita espacios y guiones, y trabaja de derecha a izquierda
  const digitos = numero.replace(/\D/g, '').split('').reverse().map(Number);
  let suma = 0;

  digitos.forEach((digito, i) => {
    let valor = digito;
    if (i % 2 === 1) {            // posiciones alternas (empezando por la segunda)
      valor *= 2;
      if (valor > 9) valor -= 9;  // equivale a sumar las dos cifras
    }
    suma += valor;
  });

  return suma % 10 === 0;
}

console.log(luhnValido('4539148803436467')); // true
console.log(luhnValido('4539148803436468')); // false

Python

def luhn_valido(numero: str) -> bool:
    digitos = [int(d) for d in str(numero) if d.isdigit()][::-1]
    suma = 0
    for i, digito in enumerate(digitos):
        valor = digito
        if i % 2 == 1:
            valor *= 2
            if valor > 9:
                valor -= 9
        suma += valor
    return suma % 10 == 0

print(luhn_valido("4539148803436467"))  # True
print(luhn_valido("4539148803436468"))  # False

PHP

function luhnValido(string $numero): bool {
    $digitos = array_reverse(str_split(preg_replace('/\D/', '', $numero)));
    $suma = 0;
    foreach ($digitos as $i => $digito) {
        $valor = (int) $digito;
        if ($i % 2 === 1) {
            $valor *= 2;
            if ($valor > 9) {
                $valor -= 9;
            }
        }
        $suma += $valor;
    }
    return $suma % 10 === 0;
}

var_dump(luhnValido('4539148803436467')); // bool(true)
var_dump(luhnValido('4539148803436468')); // bool(false)

En los tres casos el patrón es el mismo: invertir los dígitos, duplicar las posiciones impares, reducir los números de dos cifras y comprobar el módulo 10. Puedes portarlo a Java, C#, Go o cualquier otro lenguaje en minutos.

Qué detecta y qué no detecta el algoritmo de Luhn

Aquí está el malentendido más común, y conviene dejarlo claro de una vez.

Lo que sí detecta:

• Un dígito mal escrito (error de tecleo simple).
• Un intercambio de dos dígitos adyacentes, en la mayoría de los casos.
• Números incompletos o con un dígito de más.

Lo que no detecta:

• No confirma que la tarjeta exista. Un número inventado puede pasar Luhn perfectamente.
• No verifica que haya fondos ni que la tarjeta esté activa.
• No valida el CVV, la fecha de vencimiento ni el titular.
• No garantiza que el BIN sea real ni que corresponda a un emisor auténtico.
• No detecta ciertos intercambios de dígitos ni errores dobles que se compensan entre sí.

Dicho de otro modo: Luhn te dice si un número está bien formado, no si es real. Es un filtro de calidad de datos, no una autorización de pago.

Por eso, cuando un validador te dice "número válido", en realidad te dice "número válido por Luhn". La comprobación de si la tarjeta es auténtica solo la puede hacer la pasarela de pago contra el emisor, y eso forma parte de otra fase del proceso.

Un caso real de QA

Marta trabajaba como QA en una fintech y tenía un bug intermitente: el formulario de checkout rechazaba ciertas tarjetas de prueba. Después de dos días revisando el backend, descubrió que el problema estaba en una validación del frontend que exigía exactamente 16 dígitos. Las tarjetas de American Express tienen 15, así que la validación las descartaba antes de llegar al servidor. Bastó con relajar la longitud y añadir una comprobación de Luhn para que cada red aceptara su formato correcto. El bug no estaba en el algoritmo, sino en asumir que todas las tarjetas son iguales.

Otros usos del algoritmo de Luhn: IMEI, EAN y UPC

El algoritmo de Luhn no se limita a las tarjetas. Estos son algunos contextos donde lo encontrarás:

• IMEI de móviles. Los 15 dígitos del IMEI terminan en un dígito de control calculado con Luhn. Es lo que permite validar un IMEI sin consultar ninguna base de datos.
• Códigos EAN-13 y EAN-8. Los códigos de barras de productos usan un checksum compatible con la misma lógica.
• UPC-A. El código de barras de 12 dígitos de Norteamérica también aplica un dígito de control final.
• Números de identificación de algunos países y documentos de seguridad que necesitan una verificación rápida.

Que un identificador use Luhn no es casualidad: es la forma más barata de detectar errores de transcripción en cualquier número largo. Si vas a diseñar un sistema de numeración propio (cupones, licencias, códigos de pedido), Luhn es una opción excelente para añadir un dígito de control sin complicarte.

Tarjetas de prueba y Luhn van de la mano

Cuando desarrollas software de pagos, necesitas números que pasen la validación del cliente pero que no puedan usarse para comprar nada. Ahí es donde Luhn se vuelve tu aliado: puedes generar infinitos números válidos sin arriesgar datos reales. Si quieres ejemplos concretos por red, echa un vistazo a nuestro generador de tarjetas Visa o consulta el directorio de tarjetas de prueba y nuestra guía de tarjetas de prueba de Stripe y PayPal para escenarios oficiales.

¿Listo para probar con números válidos por Luhn? Abre el generador de tarjetas de crédito, elige la red y exporta hasta 9999 números en JSON, CSV o XML en segundos.

Conclusión

El algoritmo de Luhn es una de esas piezas pequeñas que sostienen sistemas enormes. Con cinco pasos y una operación módulo 10, detecta la mayoría de los errores de tecleo en cualquier número largo, sin bases de datos ni conexión.

Lo importante que debes recordar es su alcance real: valida el formato, no la autenticidad. Ese matiz es clave cuando pruebas software de pagos, porque te permite usar números inventados y válidos por Luhn sin tocar jamás datos reales.

Si trabajas en QA o desarrollo, ten siempre a mano dos herramientas: un validador para comprobar números y un generador para crear lotes de prueba. Con ambas, cualquier integración de pagos se prueba más rápido y sin riesgo.

Aviso de uso responsable: los números generados en este sitio son ficticios y válidos únicamente por el algoritmo de Luhn. No corresponden a tarjetas reales, no sirven para comprar y deben usarse solo para pruebas de software. Usarlos para fraude o suplantación es ilegal.

Fuentes y lecturas relacionadas

• Wikipedia en español, "Algoritmo de Luhn": es.wikipedia.org/wiki/Algoritmo_de_Luhn
• DBpedia en español, "Hans Peter Luhn": es.dbpedia.org/page/Hans_Peter_Luhn
• Qué es el BIN de una tarjeta y qué revelan sus primeros dígitos
• Qué es el CVV o CVC de una tarjeta y para qué sirve

Preguntas Frecuentes

¿El algoritmo de Luhn confirma que una tarjeta es real?

No. Solo comprueba que el número esté bien formado. Una tarjeta real y un número inventado pueden pasar Luhn por igual.

¿Por qué se llama "módulo 10"?

Porque el criterio final es que la suma total sea divisible entre 10, es decir, que su resto módulo 10 sea cero.

¿Luhn funciona con todas las tarjetas?

Sí, las principales redes (Visa, Mastercard, American Express, Discover, JCB y Diners Club) usan el dígito de control de Luhn, aunque cambien la longitud y el prefijo.

¿Puedo usar Luhn para validar un IMEI?

Sí. El último dígito del IMEI es un checksum de Luhn, así que el mismo código sirve para validarlo.

Luhnmódulo 10validaciónchecksum