Cómo se calcula la letra del DNI y del NIE (módulo 23, con código)

Si alguna vez has validado un DNI en un formulario, o has necesitado datos de prueba para un entorno de test, te habrás preguntado de dónde sale esa letra final. No es aleatoria ni un truco: es un dígito de control que se calcula con una operación muy simple. Vamos a verlo paso a paso y con código.

El algoritmo del DNI

Un DNI son 8 dígitos y una letra. El Ministerio del Interior publica el algoritmo [1], y la letra se obtiene así:

Toma los 8 dígitos como un número entero.
Calcula el resto de dividirlo entre 23 (módulo 23).
Busca ese resto como posición en esta tabla de 23 letras:

TRWAGMYFPDXBNJZSQVHLCKE

La posición empieza en 0. El resto 0 es T, el 1 es R, el 2 es W, y así hasta el 22, que es E.

Ejemplo

DNI 12345678:

12345678 mod 23 = 14
La posición 14 de la tabla es Z
Resultado: 12345678Z

Un caso límite del cálculo: 00000000 da resto 0, que es T, así que 00000000T.

No están todas las letras del alfabeto: faltan I, Ñ, O y U. No hay una explicación oficial fácil de encontrar. Estas son las que circulan:

I y O: en esto coinciden todas las fuentes. Se descartan porque se confunden con 1 y 0.
Ñ: hay dos versiones. Según el matemático Raúl Ibáñez (UPV/EHU), se quitó por los problemas con sistemas informáticos de otros países, que no tienen esa letra [3]. Según Wikipedia, para no confundirla con la N [4].
U: según Ibáñez, para quedarse en 23 letras. El 23 es primo, y eso es lo que permite detectar errores (lo vemos más abajo) [3].

El NIE: el mismo algoritmo con un paso previo

El NIE (número de identidad de extranjero) tiene una letra inicial X, Y o Z, siete dígitos y una letra final de control.

Un poco de historia: al principio el NIE era una X seguida de ocho dígitos. La Orden INT/2058/2008 [2] fijó el formato actual de nueve caracteres, con una letra inicial, siete dígitos y un carácter de verificación. También estableció que, al agotarse la serie de la X, se siguiera por orden alfabético. Por eso existen los NIE con Y y con Z.

Para calcular la letra final [1]:

Sustituye la letra inicial por un dígito: X → 0, Y → 1, Z → 2.
Concatena ese dígito con los 7 dígitos: obtienes un número de 8 cifras.
Aplica el mismo módulo 23 y la misma tabla.

Ejemplo

NIE X1234567:

X → 0, así que el número es 01234567
1234567 mod 23 = 19
La posición 19 de la tabla es L
Resultado: X1234567L

Con Y1234567 se calcula 11234567, y con Z1234567 se calcula 21234567.

En código (TypeScript)

const LETTERS = "TRWAGMYFPDXBNJZSQVHLCKE";
const NIE_PREFIX: Record<string, string> = { X: "0", Y: "1", Z: "2" };

// Los usuarios escriben "12.345.678-z": quita espacios, puntos y guiones.
const normalize = (s: string) => s.toUpperCase().replace(/[\s.-]/g, "");

export function dniLetter(digits: string): string {
  return LETTERS[Number(digits) % 23];
}

export function isValidDni(raw: string): boolean {
  const m = /^(\d{8})([A-Z])$/.exec(normalize(raw));
  return m !== null && dniLetter(m[1]) === m[2];
}

export function isValidNie(raw: string): boolean {
  const m = /^([XYZ])(\d{7})([A-Z])$/.exec(normalize(raw));
  return m !== null && dniLetter(NIE_PREFIX[m[1]] + m[2]) === m[3];
}

isValidDni("12345678Z"); // true
isValidDni("12.345.678-z"); // true
isValidDni("12345678A"); // false
isValidNie("X1234567L"); // true

Un detalle práctico: normaliza siempre antes de validar. Es lo que hace normalize. Si no, rechazarás documentos correctos escritos con puntos, guiones o en minúsculas.

Qué valida y qué no

La letra detecta errores de tecleo. Si te equivocas en un dígito o intercambias dos cifras, la letra ya no cuadra, porque ninguno de esos cambios deja el mismo resto al dividir entre 23. Lo que no hace es comprobar que el documento exista. 12345678Z es un DNI con formato y letra válidos, pero eso no dice nada de si pertenece a alguien.

Esto tiene una consecuencia útil para testing: puedes generar miles de DNI con letra correcta que pasan cualquier validación de formato sin corresponder a personas reales.