Validar un RUT chileno en JavaScript, Python y PHP
Respuesta rápida
Para validar un RUT en código: quita puntos, guion y espacios; separa el número del último carácter; calcula el dígito con el módulo 11 (cifras de derecha a izquierda por 2, 3, 4, 5, 6 y 7, suma, resto de dividir por 11 y 11 menos el resto) y compáralo. Abajo están las funciones en JavaScript, Python, PHP y MySQL, sin librerías, probadas con más de 6.000 casos.
El algoritmo, en cinco pasos
- Limpia el texto: fuera puntos, guion y espacios, y la k a mayúscula.
- Separa el último carácter (el dígito escrito) del resto (el número).
- Multiplica las cifras del número desde la derecha por 2, 3, 4, 5, 6, 7, y vuelve a empezar en 2 si quedan cifras.
- Suma los productos y calcula
11 - (suma % 11). Si da 11, el dígito es 0; si da 10, es K. - Compara el dígito calculado con el escrito.
Si quieres ver la cuenta hecha con un ejemplo, la calculadora del dígito verificador la muestra paso a paso.
JavaScript
Funciona igual en el navegador y en Node.js. Recibe el RUT como texto en cualquier formato.
function calcularDv(cuerpo) {
let suma = 0;
let factor = 2;
for (let i = cuerpo.length - 1; i >= 0; i--) {
suma += Number(cuerpo[i]) * factor;
factor = factor === 7 ? 2 : factor + 1;
}
const r = 11 - (suma % 11);
return r === 11 ? "0" : r === 10 ? "K" : String(r);
}
function validarRut(rut) {
const limpio = String(rut).replace(/[.\-\s]/g, "").toUpperCase();
if (!/^\d{6,8}[0-9K]$/.test(limpio)) return false;
return calcularDv(limpio.slice(0, -1)) === limpio.slice(-1);
}
function formatearRut(rut) {
const limpio = String(rut).replace(/[.\-\s]/g, "").toUpperCase();
const cuerpo = limpio.slice(0, -1).replace(/\B(?=(\d{3})+(?!\d))/g, ".");
return cuerpo + "-" + limpio.slice(-1);
}
validarRut("12.345.678-5"); // true
formatearRut("123456785"); // "12.345.678-5"Python
Para Python 3. Solo usa el módulo re de la biblioteca estándar.
import re
def calcular_dv(cuerpo: str) -> str:
suma = 0
factor = 2
for cifra in reversed(cuerpo):
suma += int(cifra) * factor
factor = 2 if factor == 7 else factor + 1
r = 11 - (suma % 11)
return "0" if r == 11 else "K" if r == 10 else str(r)
def validar_rut(rut: str) -> bool:
limpio = re.sub(r"[.\-\s]", "", str(rut)).upper()
if not re.fullmatch(r"\d{6,8}[0-9K]", limpio):
return False
return calcular_dv(limpio[:-1]) == limpio[-1]
def formatear_rut(rut: str) -> str:
limpio = re.sub(r"[.\-\s]", "", str(rut)).upper()
cuerpo = f"{int(limpio[:-1]):,}".replace(",", ".")
return f"{cuerpo}-{limpio[-1]}"
validar_rut("12.345.678-5") # True
formatear_rut("123456785") # '12.345.678-5'PHP
Para PHP 7.4 o superior. Sirve tal cual en Laravel, WordPress o un formulario simple.
<?php
function calcularDv(string $cuerpo): string {
$suma = 0;
$factor = 2;
for ($i = strlen($cuerpo) - 1; $i >= 0; $i--) {
$suma += (int) $cuerpo[$i] * $factor;
$factor = $factor === 7 ? 2 : $factor + 1;
}
$r = 11 - ($suma % 11);
return $r === 11 ? '0' : ($r === 10 ? 'K' : (string) $r);
}
function validarRut(string $rut): bool {
$limpio = strtoupper(preg_replace('/[.\-\s]/', '', $rut));
if (!preg_match('/^\d{6,8}[0-9K]$/', $limpio)) return false;
return calcularDv(substr($limpio, 0, -1)) === substr($limpio, -1);
}
function formatearRut(string $rut): string {
$limpio = strtoupper(preg_replace('/[.\-\s]/', '', $rut));
return number_format((int) substr($limpio, 0, -1), 0, ',', '.') . '-' . substr($limpio, -1);
}
validarRut('12.345.678-5'); // true
formatearRut('123456785'); // '12.345.678-5'MySQL
Para MySQL 8. Sirve para revisar los RUT que ya están guardados en una tabla, sin sacarlos de la base. Si tu servidor tiene el registro binario activo, puede que necesites permisos para crear funciones.
DELIMITER //
CREATE FUNCTION rut_dv(cuerpo INT UNSIGNED) RETURNS CHAR(1) DETERMINISTIC
BEGIN
DECLARE suma INT DEFAULT 0;
DECLARE factor INT DEFAULT 2;
WHILE cuerpo > 0 DO
SET suma = suma + (cuerpo % 10) * factor;
SET cuerpo = cuerpo DIV 10;
SET factor = IF(factor = 7, 2, factor + 1);
END WHILE;
RETURN ELT(11 - (suma % 11), '1','2','3','4','5','6','7','8','9','K','0');
END //
CREATE FUNCTION rut_valido(rut VARCHAR(20)) RETURNS BOOLEAN DETERMINISTIC
BEGIN
DECLARE limpio VARCHAR(20) DEFAULT UPPER(REPLACE(REPLACE(REPLACE(rut, '.', ''), '-', ''), ' ', ''));
IF limpio NOT REGEXP '^[0-9]{6,8}[0-9K]$' THEN
RETURN FALSE;
END IF;
RETURN rut_dv(CAST(LEFT(limpio, CHAR_LENGTH(limpio) - 1) AS UNSIGNED)) = RIGHT(limpio, 1);
END //
DELIMITER ;
-- Los RUT mal escritos de una tabla:
SELECT id, rut FROM clientes WHERE NOT rut_valido(rut);ELT traduce el resultado de 11 menos el resto al dígito: 10 da K y 11 da 0, sin escribir condiciones.
Revisar solo el formato con una expresión regular
Una expresión regular no puede comprobar el dígito verificador, pero sirve para avisar mientras la persona escribe. Esta acepta el RUT con puntos y guion, solo con guion o sin nada:
^(\d{1,2}(\.\d{3}){2}|\d{3}\.\d{3}|\d{6,8})-?[\dkK]$Úsala para el aviso de formato y deja la decisión final a la función de validación, que es la que revisa el dígito.
Casos para probar tu implementación
| Entrada | Resultado esperado | Por qué |
|---|---|---|
| 12.345.678-5 | Válido | Formato habitual |
| 123456785 | Válido | Sin puntos ni guion |
| 8.765.432-k | Válido | Dígito K en minúscula |
| 10.000.004-0 | Válido | Dígito 0 |
| 999.999-K | Válido | RUN antiguo de seis cifras |
| 12.345.678-0 | Inválido | El dígito no corresponde |
| 12.345.678 | Inválido | Le falta el dígito: el 8 se lee como dígito |
Las cuatro implementaciones de esta página devuelven exactamente esos resultados. Antes de publicarlas las probamos con más de 6.000 casos generados al azar, incluidos dígitos K y 0.
Validar no es verificar identidad
Que el dígito coincida solo prueba que el RUT está bien escrito: no dice que exista ni de quién es. Si tu sistema necesita confirmar una empresa, consulta su situación en el SII; si necesita confirmar a una persona, pídele su cédula o usa ClaveÚnica.
Valida en el navegador para avisar el error al tiro, y vuelve a validar en el servidor, que es donde se decide. Y recuerda que el RUT de una persona es un dato personal: guárdalo solo si lo necesitas y protégelo como tal. La Ley 21.719 refuerza esas obligaciones desde el 1 de diciembre de 2026; lo resumimos en protección de datos en Chile.
Preguntas frecuentes
¿Hay una librería para validar RUT?
Hay varias en npm, PyPI y Packagist, pero el algoritmo cabe en diez líneas. Copiar una función corta y probada te ahorra una dependencia.
¿Puedo usar estas funciones en mi proyecto?
Sí, puedes copiarlas y adaptarlas libremente, también en proyectos comerciales.
¿Cuántas cifras puede tener un RUT?
Hoy el número tiene entre seis y ocho cifras, más el dígito verificador. Las funciones aceptan ese rango; si algún día se asignan RUT de nueve cifras, basta con ampliar la expresión regular.
¿La K se compara en mayúscula o minúscula?
Las funciones pasan todo a mayúscula antes de comparar, así que 8.765.432-k y 8.765.432-K son válidos. Guárdala siempre en mayúscula para no tener duplicados.
¿Y si necesito validar una planilla en vez de un formulario?
Usa las fórmulas para Excel y Google Sheets o pega la lista en el validador masivo.
También te puede servir
Este artículo no usa bases de datos de personas. Fuentes: Registro Civil, SII, Ley 19.628 y Ley 21.719. Última verificación: 15-10-2026.