Saltar al contenido

Validar un RUT chileno en JavaScript, Python y PHP

Actualizado: octubre 2026Verificado con fuentes oficiales

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.

JavaScript
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.

Python
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
<?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.

MySQL
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:

Expresión regular
^(\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

EntradaResultado esperadoPor qué
12.345.678-5VálidoFormato habitual
123456785VálidoSin puntos ni guion
8.765.432-kVálidoDígito K en minúscula
10.000.004-0VálidoDígito 0
999.999-KVálidoRUN antiguo de seis cifras
12.345.678-0InválidoEl dígito no corresponde
12.345.678InválidoLe 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?

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.

¿Se lo mandas a alguien?

WhatsApp