Generador de RUT chileno válido

Qué es el generador de RUT

El generador de RUT crea números de RUT chilenos matemáticamente válidos: un cuerpo aleatorio con su dígito verificador correcto, calculado con el algoritmo módulo 11. Está pensado para desarrolladores, testers y profesionales que necesitan datos de prueba para formularios y sistemas sin usar el RUT de una persona real.

Funciona íntegramente en tu navegador: no consulta ninguna base de datos ni envía nada a internet. El número se genera y se valida en tu propio dispositivo, de forma instantánea.

Cómo funciona el algoritmo del dígito verificador

Generar un RUT válido tiene dos pasos: crear un cuerpo aleatorio y calcular su dígito verificador con el algoritmo módulo 11. Ese cálculo es el corazón del generador, y es el mismo que verifica el validador de RUT.

El cálculo, paso a paso

Para un cuerpo como 12.345.678:

1. Recorre el cuerpo de derecha a izquierda y multiplica cada dígito por la serie 2, 3, 4, 5, 6, 7 (que se repite): 8×2, 7×3, 6×4, 5×5, 4×6, 3×7, 2×2, 1×3.
2. Suma los productos: 16+21+24+25+24+21+4+3 = 138.
3. Calcula el resto de dividir por 11: 138 ÷ 11 deja resto 6.
4. Resta a 11: 11 − 6 = 5. Ese es el dígito verificador.

Las dos excepciones: si el resultado es 11, el dígito es 0; si es 10, es K. El detalle completo con más ejemplos está en la guía del dígito verificador.

Para qué sirve un generador de RUT

El uso legítimo del generador es siempre el mismo: datos de prueba. Estos son los casos más frecuentes:

• Probar formularios: verificar que un campo de RUT valida correctamente, con números que pasan y otros que no.
• Poblar bases de datos de desarrollo: cargar cientos de registros de prueba sin usar datos reales.
• Pruebas automatizadas: generar RUT válidos en tests que verifican el comportamiento de un sistema.
• Demostraciones: mostrar cómo funciona un sistema sin exponer datos de clientes reales.
• Capacitación: enseñar a usar un software con datos ficticios pero con formato correcto.

El hilo común: el RUT generado nunca sale de un entorno de prueba ni se usa para representar a una persona real.

Uso ético y legal

Que un RUT sea válido no lo hace legítimo para cualquier uso. La línea es clara:

Suplantar una identidad o usar un documento falso son delitos en Chile, y el hecho de que el RUT sea matemáticamente válido no cambia nada: lo que importa es el uso, no el número.

Generar un RUT en código: JavaScript, PHP y Python

Si necesitas generar RUT dentro de tu propio proyecto, aquí tienes la implementación en los tres lenguajes más habituales. La lógica es idéntica: un cuerpo aleatorio y el cálculo del dígito verificador.

JavaScript

function digitoVerificador(cuerpo) {
  let suma = 0, mul = 2;
  for (let i = cuerpo.length - 1; i >= 0; i--) {
    suma += parseInt(cuerpo[i], 10) * mul;
    mul = mul === 7 ? 2 : mul + 1;
  }
  const res = 11 - (suma % 11);
  return res === 11 ? '0' : res === 10 ? 'K' : String(res);
}

function generarRut(min = 1000000, max = 25000000) {
  const cuerpo = String(Math.floor(Math.random() * (max - min + 1)) + min);
  return cuerpo + '-' + digitoVerificador(cuerpo);
}

console.log(generarRut()); // ej: 14837291-K

PHP

function digitoVerificador($cuerpo) {
  $suma = 0; $mul = 2;
  for ($i = strlen($cuerpo) - 1; $i >= 0; $i--) {
    $suma += intval($cuerpo[$i]) * $mul;
    $mul = $mul === 7 ? 2 : $mul + 1;
  }
  $res = 11 - ($suma % 11);
  return $res === 11 ? '0' : ($res === 10 ? 'K' : strval($res));
}

function generarRut($min = 1000000, $max = 25000000) {
  $cuerpo = strval(rand($min, $max));
  return $cuerpo . '-' . digitoVerificador($cuerpo);
}

echo generarRut(); // ej: 9482017-3

Python

import random

def digito_verificador(cuerpo: str) -> str:
    suma, mul = 0, 2
    for c in reversed(cuerpo):
        suma += int(c) * mul
        mul = 2 if mul == 7 else mul + 1
    res = 11 - (suma % 11)
    return '0' if res == 11 else 'K' if res == 10 else str(res)

def generar_rut(minimo=1_000_000, maximo=25_000_000) -> str:
    cuerpo = str(random.randint(minimo, maximo))
    return f"{cuerpo}-{digito_verificador(cuerpo)}"

print(generar_rut())  # ej: 20194857-6

Para validar un RUT en lugar de generarlo, la lógica del dígito verificador es la misma: compara el dígito calculado con el que trae el RUT. Los ejemplos completos de validación están en la guía de validar RUT en programación.

RUT de prueba frente a RUT real

Es una distinción que confunde a muchos desarrolladores nuevos. Un RUT puede estar en tres estados distintos:

• Inválido: el dígito verificador no cuadra. Un formulario debe rechazarlo.
• Válido pero ficticio: pasa el módulo 11, pero no está asignado a nadie. Es lo que produce el generador.
• Válido y real: pasa el módulo 11 y además está asignado a una persona o empresa registrada.

El generador y el validador trabajan solo con las dos primeras categorías: verifican el formato, no la existencia. Para saber si un RUT está asignado a un contribuyente real hay que consultarlo en el SII, algo que solo tiene sentido para empresas —el rutificador de empresas lo hace—.

Generar un RUT de empresa

El algoritmo es idéntico; lo único que cambia es el rango. Los RUT de empresa se asignan habitualmente por sobre los 60 millones, comenzando por 7, 8 o 9. Para generar uno de prueba en ese rango, basta ajustar los límites del número aleatorio (por ejemplo, entre 60.000.000 y 99.999.999) y calcular su dígito verificador igual que antes.

Al igual que los de persona, un RUT de empresa generado no corresponde a ninguna sociedad real ni tiene inicio de actividades: sirve solo como dato de prueba.

Errores comunes al generar y usar RUT de prueba

Usar un RUT generado como real

El error más grave, y el único que tiene consecuencias legales. Un RUT válido no es un RUT tuyo: usarlo en un trámite es suplantación.

Olvidar probar los casos con K

Un buen set de pruebas incluye RUT cuyo dígito verificador sea K y 0, porque son los casos límite del algoritmo. Muchos formularios fallan justamente ahí.

No probar RUT inválidos

Generar solo RUT válidos prueba la mitad del formulario. Para el otro caso, cambia un dígito a mano y verifica que el sistema lo rechace como corresponde.

Confundir generar con validar

Son operaciones opuestas: el generador crea un RUT válido; el validador comprueba si uno lo es. Ambos usan el mismo cálculo del dígito verificador, en direcciones distintas.

Fuentes y referencias

Herramientas relacionadas

• Validar un RUT — comprueba si un RUT es válido.
• Validar RUT en programación — ejemplos en JS, PHP y Python.
• El dígito verificador — el algoritmo módulo 11.
• El formato del RUT — cómo se escribe correctamente.