Quick Start

This guide takes you from an untrusted string to a clean, validated RUT ready for storage — the path almost every integration needs.

New here? Skim What is a RUT? first. Already installed? Jump straight in. Not installed yet — see Installation.

The five-minute path#

Format input as the user types

Incremental mode formats progressively and never throws, so it is safe to call on every keystroke.

TypeScript

import { format } from 'rut.ts'
 
format('12345678', { incremental: true }) // '1.234.567-8'
format('123456785', { incremental: true }) // '12.345.678-5'

Validate on blur or submit

validate() checks the shape and the Modulo 11 verifier digit. Use strict: true as the final acceptance gate for real identities.

TypeScript

import { validate } from 'rut.ts'
 
validate('12.345.678-5')                  // true
validate('12.345.678-5', { strict: true }) // true
validate('11.111.111-1', { strict: true }) // false (placeholder)

Clean for storage

Store a single canonical shape regardless of how the user typed it.

TypeScript

import { clean } from 'rut.ts'
 
clean('12.345.678-5') // '123456785'

Decompose if your schema splits it

Some schemas keep body and verifier in separate columns.

TypeScript

import { decompose } from 'rut.ts'
 
const { body, verifier } = decompose('12.345.678-5')
// body: '12345678', verifier: '5'

Try the whole flow#

Type below — validate(), format(), clean(), and decompose() all run on every keystroke:

Try it — type any RUT

isRutLike()true

validate()true

validate({ strict: true })true

clean()123456785

format()12.345.678-5

decompose().body12345678

decompose().verifier5

calculateVerifier(body)5

verifier if input is a bodynot applicable

Putting it together#

A complete, copy-pasteable handler that accepts user input, validates it strictly, and returns a storage-ready value:

TypeScript

import { validate, clean } from 'rut.ts'
 
function acceptRut(input: unknown):
  | { ok: true; rut: string }
  | { ok: false; error: string } {
  if (typeof input !== 'string') {
    return { ok: false, error: 'RUT is required' }
  }
 
  // Final acceptance gate: shape + verifier + no placeholders.
  if (!validate(input, { strict: true })) {
    return { ok: false, error: 'Invalid RUT' }
  }
 
  // Safe by construction: validate() already passed.
  return { ok: true, rut: clean(input) }
}
 
acceptRut('12.345.678-5')  // { ok: true, rut: '123456785' }
acceptRut('11.111.111-1')  // { ok: false, error: 'Invalid RUT' }
acceptRut(123456785)       // { ok: false, error: 'RUT is required' }

Rule of thumb: format() for display, validate({ strict: true }) to accept, clean() to store. Never trust clean() or decompose() output as “validated” — they normalize shape but do not check the verifier digit.

Where to next#

Form Integration

React Hook Form, Zod, Formik, Yup, and Server Actions.

Security

Why strict mode and bounded input matter for identity flows.

API Reference

Every signature, option, and type.

Features

The nine functions in depth.

Edit this page on GitHub

← PreviousInstallation Next →Migration to v4