Por eso escribí sii_bot, un script en Python que entra al portal del SII, declara el mes sin movimiento y guarda el folio. En este artículo explico qué exige la ley, cómo funciona el bot y, sobre todo, qué le falta a un script que "funciona en mi computador" para que una empresa pueda confiar en él.

Qué exige el SII

El F29 es la declaración mensual de IVA. Según el SII, quienes están afectos a IVA deben presentarlo desde el mes en que inician actividades, aun cuando no tengan operaciones. Si no hubo ventas ni compras, se declara "sin movimiento".

Los plazos dependen de cómo y qué declares:

Si el último día cae en sábado, domingo, feriado o 31 de diciembre, el plazo se corre al día hábil siguiente (SII, plazos del F29). La declaración sin movimiento no se puede presentar en papel.

¿Y si se te pasa? El artículo 97 N°2 del Código Tributario sanciona las declaraciones que no implican un pago inmediato y se presentan fuera de plazo con una multa de 1 UTM a 1 UTA (texto en LeyChile). Es poco dinero comparado con una empresa en operación, pero es plata pagada por nada.

Ojo con dos detalles. Si tu empresa sí tuvo movimiento y lo declaras "sin movimiento", tendrás que rectificar y pagar multas e intereses sobre el impuesto que correspondía. Y estar sin movimiento no te libera de la Operación Renta: según el SII, incluso tras más de 24 meses sin movimiento hay que preparar el balance y declarar la renta anual.

Qué hace el bot, paso a paso

El flujo es exactamente el que harías tú en el navegador, pero sin que tengas que acordarte:

1. Inicia sesión en el SII con el RUT y la clave de la empresa, que lee desde un archivo .env.
2. Abre la declaración del F29 y elige el período anterior: si hoy es octubre, declara septiembre.
3. Marca la declaración sin movimiento y confirma el envío.
4. Busca el folio en la consulta de declaraciones del SII.
5. Anota el período, la fecha y el folio en un CSV, que queda como registro.

Usa Selenium para manejar Chrome como lo haría una persona. Es la opción natural cuando el portal no ofrece una API para hacer el trámite, y es la misma técnica que usamos para otros trámites del portal en el caso de bots para el SII.

Calcular el período parece trivial, pero tiene su trampa. La primera versión usaba locale y strftime("%B") para obtener el nombre del mes en español. Eso depende de que el sistema tenga instalado el idioma español, y en muchos servidores no está: el script falla antes de empezar. Una tabla propia evita el problema:

from datetime import date

MESES = ["enero", "febrero", "marzo", "abril", "mayo", "junio", "julio",
         "agosto", "septiembre", "octubre", "noviembre", "diciembre"]


def periodo_anterior(hoy: date) -> tuple[str, int]:
    """Mes y año que se declaran: siempre el mes anterior al actual."""
    if hoy.month == 1:
        return MESES[11], hoy.year - 1
    return MESES[hoy.month - 2], hoy.year


print(periodo_anterior(date(2026, 1, 8)))   # ('diciembre', 2025)
print(periodo_anterior(date(2026, 10, 14)))  # ('septiembre', 2026)

De script a proceso: lo que cambiaríamos

La versión publicada en GitHub resuelve mi caso: un computador, una empresa y yo mirando la pantalla. Para que una empresa lo deje corriendo sin mirar, hay que resolver cinco cosas más. Estas son las que revisamos en cualquier automatización antes de darla por terminada.

1. Esperar a que la página esté lista, no un tiempo fijo

El script original espera segundos fijos entre pasos (countdown(5), countdown(7)). Si el SII está lento ese día, el clic llega antes que el botón y todo falla. Si está rápido, pierdes tiempo. Selenium permite esperar hasta que el elemento esté disponible:

from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait


def clic(driver, selector: str, segundos: int = 30) -> None:
    """Hace clic apenas el botón se puede usar, con un máximo de espera."""
    boton = WebDriverWait(driver, segundos).until(
        EC.element_to_be_clickable((By.CSS_SELECTOR, selector))
    )
    boton.click()

2. Selectores que sobrevivan a un cambio de diseño

Rutas como /html/body/div[1]/div/div/div/div[3]/button[2] se rompen con cualquier ajuste en la página. Conviene buscar elementos por su id, por su etiqueta o por el texto del botón, que cambian mucho menos que la estructura.

3. Saber si ya está hecho antes de hacerlo

En la primera versión, si el envío fallaba el script imprimía "este mes ya fue declarado o ocurrió un error". Son dos situaciones muy distintas: una es éxito y la otra exige actuar. Un proceso confiable revisa antes de actuar y verifica después:

import csv
from pathlib import Path

REGISTRO = Path("declaraciones/meses_declarados.csv")


def ya_declarado(periodo: str) -> bool:
    """True si el período ya tiene folio en el registro."""
    if not REGISTRO.exists():
        return False
    with REGISTRO.open(newline="", encoding="utf-8") as f:
        return any(fila["periodo"] == periodo and fila["folio"] for fila in csv.DictReader(f))

Con esa función el bot puede correr todos los días sin riesgo: si el mes ya tiene folio, no hace nada. Después de enviar, consulta el folio en el SII. Si no lo encuentra, no lo da por hecho: avisa.

4. Evidencia que no se pueda confundir

Revisando el código para este artículo encontramos un error que vale como lección. El paso que descarga el certificado en PDF quedó comentado, pero la función que renombra "el último PDF de la carpeta" sigue activa. Si la carpeta tiene el PDF del mes anterior, lo renombra como si fuera el actual. La regla es simple: nunca supongas qué se descargó. Verifica el nombre, la fecha y, si se puede, el contenido.

5. Un calendario y alguien que reciba el aviso

Un script que corre solo cuando te acuerdas de abrirlo tiene el mismo problema que la declaración manual. En un servidor Linux basta una línea de cron (en Windows, el Programador de tareas):

# Todos los días a las 9:00, del 5 al 25 de cada mes
0 9 5-25 * * /opt/sii_bot/.venv/bin/python /opt/sii_bot/main.py

Como el bot revisa antes de actuar, correr todos los días no duplica nada: el primer día declara y los siguientes solo confirman. Si el día 25 todavía no hay folio, quedan tres días para resolverlo a mano antes del 28. Cada resultado (el folio o el error) debería llegar a quien corresponde, por correo o por un grupo de Telegram.

La clave tributaria merece su propio cuidado. Un .env en un notebook sirve para probar. En producción la clave vive en el servidor, fuera del repositorio y con acceso restringido.

Cuándo conviene y cuándo no

Conviene para sociedades sin actividad: SpA recién creadas, sociedades de inversión, empresas en pausa o un contador que lleva varias de ellas. Para varias empresas, el mismo bot recorre una lista de RUT.

No conviene declarar sin movimiento de forma automática si la empresa tiene movimiento. Ahí el F29 lleva montos reales y el camino es otro: la propuesta de declaración que arma el SII con el Registro de Compras y Ventas. Una automatización puede prepararla y revisar las diferencias, pero la aprobación final la da una persona. Así trabajamos en Star Apps: la máquina hace el trabajo repetitivo y tu equipo revisa, aprueba y decide.

El código está en GitHub. Si quieres que corra en un servidor, con avisos y para varias empresas, conversemos.

AutoRead es la versión que reescribí en 2026 con una sola meta: no hacer más cosas, sino hablar mejor. Este artículo explica cómo está hecha y qué decisiones hacen la diferencia. Al final verás que la misma idea quedó integrada en este blog: si prefieres escuchar este texto en vez de leerlo, usa el botón Escuchar artículo de arriba.

Cómo se usa

1. Selecciona un texto en cualquier página.
2. Abre AutoRead desde la barra de extensiones.
3. Elige la voz, o déjala en automático, y la velocidad, entre 0,5x y 3x.
4. Presiona Leer. Puedes detenerla cuando quieras.

La voz y la velocidad quedan guardadas para la próxima vez.

Cómo está hecha

Es una extensión de Chrome con Manifest V3, el formato actual de extensiones. Tiene tres piezas, cada una con una sola tarea:

• El panel (popup.html y popup.js): los controles de voz, velocidad, leer y detener.
• El service worker (background.js): obtiene el texto seleccionado con chrome.scripting, lo prepara y se lo entrega al motor de voz del navegador con chrome.tts.
• El manifiesto (manifest.json): declara los permisos que necesita, que son activeTab, scripting, storage y tts.

Cuando la voz está en automático, detecta el idioma del texto con chrome.i18n.detectLanguage y elige una voz de ese idioma. Las preferencias se guardan con chrome.storage.local.

Tres decisiones para que no suene a robot

1. Limpiar el texto antes de leerlo

El texto copiado de una página trae ruido que un motor de voz lee tal cual: direcciones web, viñetas, saltos de línea y espacios de más. Una limpieza mínima cambia mucho la experiencia:

function limpiarParaLeer(texto) {
  return texto
    .replace(/­/g, '')                // guiones invisibles de partición
    .replace(/https?:\/\/\S+/g, 'enlace')  // nadie quiere oír una URL letra por letra
    .replace(/^[•\-*]\s+/gm, ', ')         // las viñetas se vuelven pausas breves
    .replace(/[ \t]+/g, ' ')
    .trim();
}

Los saltos de línea se conservan a propósito: marcan dónde termina cada párrafo, y eso se usa en el paso siguiente.

2. Dividir por párrafos, no por comas

Un motor de voz decide la entonación según el fragmento que recibe. Si le entregas el texto cortado en cada coma, cada pedazo suena como una frase aparte, con la voz subiendo y bajando sin sentido. Si le entregas el párrafo completo, la entonación acompaña la idea.

AutoRead envía un párrafo a la vez. Solo si un párrafo supera los 1.500 caracteres lo divide en oraciones:

function enTrozos(texto, maximo = 1500) {
  return texto
    .split(/\n+/)                          // un trozo por párrafo
    .map((p) => p.trim())
    .filter(Boolean)
    .flatMap((p) => (p.length <= maximo ? [p] : p.match(/[^.!?]+[.!?]*/g).map((s) => s.trim())));
}

Los trozos se leen en orden: cuando el motor avisa que terminó uno, empieza el siguiente. Así nunca se superponen y detener la lectura es inmediato.

3. La voz correcta para el idioma

Una voz en inglés leyendo español suena peor que cualquier robot. Por eso el modo automático detecta el idioma antes de elegir la voz.

Hay un detalle que importa en una empresa. Las voces disponibles son de dos tipos. Las locales vienen con el sistema operativo y convierten el texto en audio dentro del computador. Las en línea, como las de Google en Chrome o las voces "Natural" de Edge, suenan mejor, pero el texto viaja a los servidores del proveedor para convertirse en audio. Para un artículo público da lo mismo. Para un contrato o un informe interno, conviene elegir una voz local.

La misma idea, integrada en este blog

Cada artículo de este blog tiene un botón Escuchar artículo. Una página web no puede usar chrome.tts, que es exclusivo de las extensiones, así que usa la Web Speech API, que viene en los navegadores modernos. Las reglas son las mismas: limpiar el texto, leer por bloques (títulos, párrafos y elementos de lista) y preferir una voz en español. Los bloques de código se anuncian, pero no se leen, y el párrafo que se está leyendo queda destacado para que puedas seguirlo con la vista.

Aprendimos una cosa más en el camino. En Chrome, algunas voces en línea pueden cortarse cuando un fragmento es muy largo. Por eso aquí los párrafos largos se agrupan en oraciones de hasta unos 220 caracteres, sin cortar nunca una oración por la mitad. El núcleo cabe en pocas líneas:

function leer(trozos, voz, i = 0) {
  if (i >= trozos.length) return;
  const frase = new SpeechSynthesisUtterance(trozos[i]);
  frase.lang = voz?.lang ?? 'es-CL';
  if (voz) frase.voice = voz;
  frase.onend = () => leer(trozos, voz, i + 1);  // el siguiente trozo empieza al terminar este
  speechSynthesis.speak(frase);
}

Las voces cargan de forma asíncrona: la primera llamada a speechSynthesis.getVoices() puede venir vacía. Hay que escuchar el evento voiceschanged antes de elegir una.

Para qué sirve en una empresa

• Accesibilidad. Para personas con baja visión, dislexia o fatiga visual, escuchar es la diferencia entre leer un documento largo o dejarlo para después.
• Revisar mejor. Escuchar un informe mientras sigues el texto ayuda a encontrar errores que la vista se salta, porque el oído no completa palabras como lo hace el ojo.
• Manuales y procedimientos. Un procedimiento que se puede escuchar llega a quien no tiene tiempo de sentarse a leerlo.

No requiere licencias ni servicios externos: la voz ya está en el navegador. Agregar un botón de escuchar a una intranet, un visor de reportes o un sistema interno es poco trabajo y le sirve a todo el equipo.

Cómo instalarla

AutoRead no está en la tienda de Chrome. Se instala desde el código:

1. Descarga o clona el repositorio.
2. Abre chrome://extensions y activa el Modo de desarrollador.
3. Presiona Cargar descomprimida y elige la carpeta del proyecto.
4. Fíjala en la barra con el ícono de la pieza de rompecabezas.

En Edge (edge://extensions) y Brave (brave://extensions) los pasos son los mismos.

Si la usas y se te ocurre una mejora, abre un issue o haz un fork. Así creció GPT_scraper.

El repositorio tiene hoy 139 estrellas y 12 forks en GitHub. No es por el código, que era sencillo. Es porque mucha gente tenía el mismo problema: sus datos estaban ahí, pero sin una salida.

Ese problema es exactamente el que vemos en las empresas. El portal del proveedor muestra las órdenes pero no las exporta. La plataforma antigua guarda años de historia y nadie sabe cómo sacarla. El sitio del Estado obliga a descargar documento por documento. Lo que aprendimos con GPT_scraper se aplica tal cual.

La idea clave: toda página web conversa con un servidor

Una aplicación web moderna no trae los datos escritos en la página. El navegador los pide a un servidor, casi siempre en formato JSON, y después los dibuja. Puedes verlo tú mismo: abre las herramientas de desarrollo del navegador (F12), ve a la pestaña Network o Red, filtra por Fetch/XHR y recarga la página. Cada línea es una de esas conversaciones.

De ahí salen los dos caminos.

Camino 1: llamar a los mismos servicios que usa la web

Si la página pide los datos a una dirección, tu programa puede pedirlos a la misma dirección con tu sesión. En GPT_scraper había dos llamadas: una que listaba las conversaciones por páginas de 100 y otra que traía cada conversación completa a partir de su identificador.

El procedimiento es siempre parecido:

1. Encuentra en la pestaña Network la llamada que trae lo que necesitas.
2. Cópiala con clic derecho, Copy as cURL, y pruébala en una herramienta como Postman o Insomnia.
3. Identifica qué cabeceras identifican tu sesión y cómo funciona la paginación.
4. Reprodúcela en Python con requests.

Revisando el código para este artículo encontramos un error de paginación en la versión original. Después de la primera página sumaba 101 al desplazamiento en vez de 100, así que se saltaba una conversación. Así se recorre una lista paginada sin ese problema:

import random
import time

import requests


def traer_todo(session: requests.Session, url: str, por_pagina: int = 100) -> list[dict]:
    """Recorre un servicio paginado con offset y limit hasta la última página."""
    items, offset = [], 0
    while True:
        r = session.get(url, params={"offset": offset, "limit": por_pagina}, timeout=30)
        r.raise_for_status()
        pagina = r.json()["items"]
        items.extend(pagina)
        if len(pagina) < por_pagina:
            return items
        offset += por_pagina
        time.sleep(random.uniform(2, 5))  # ritmo de persona, no de ataque

La session lleva las cabeceras de tu propia sesión, las mismas que copiaste del navegador. La pausa aleatoria entre páginas no es un detalle. GPT_scraper esperaba de 2 a 5 segundos entre conversaciones para no ser bloqueado, y la versión con navegador sí llegó a ser bloqueada por pedir demasiado.

A favor: es rápido, entrega datos ordenados y no depende del diseño de la página. Si cambian los colores o mueven un botón, sigue funcionando.

En contra: esos servicios no están documentados y pueden cambiar sin aviso. La sesión expira, y hay que respetar los límites de velocidad y los términos de uso del sistema.

Camino 2: manejar un navegador como lo haría una persona

Cuando no hay una llamada clara que reproducir, queda el navegador. Herramientas como Selenium o Playwright abren Chrome, inician sesión, hacen clic, llenan formularios y leen lo que aparece en pantalla. El segundo script de GPT_scraper hacía eso: abría cada conversación y copiaba el texto.

Es la misma técnica de nuestro bot que declara el F29 en el SII. Ahí no hay datos que leer, sino un trámite que hacer: elegir el período, confirmar y guardar el folio.

A favor: funciona casi siempre, porque hace lo mismo que una persona. Sirve para formularios, descargas de PDF y páginas que se arman en el servidor.

En contra: es más lento y se rompe cuando cambia el diseño de la página. Además, necesita esperas bien hechas y avisos cuando algo falla.

Cómo elegimos en un proyecto

Antes de escribir una línea de código, recorremos estas opciones en orden. Cada una cuesta más de mantener que la anterior:

La segunda fila es la más subestimada. Muchas veces el sistema ya envía un reporte diario por correo que nadie aprovecha, y automatizar su lectura es lo más barato y lo más estable.

Lo que no hay que hacer

• Entrar con credenciales ajenas o saltarse protecciones. En Chile, la Ley 21.459 sanciona a quien accede a un sistema "sin autorización o excediendo la autorización que posea" superando barreras técnicas. Se automatiza con tu cuenta, sobre tus datos y con permiso de quien administra el sistema.
• Ignorar los términos de uso. Muchos servicios prohíben el acceso automatizado a su aplicación web. GPT_scraper solo usaba tu cuenta y tus conversaciones. Aun así, hoy existe una forma oficial, y es la que corresponde usar.
• Saturar el servidor. Pausas, horarios de baja carga y guardar lo que ya descargaste para no pedirlo dos veces.
• Dejar contraseñas o tokens en el código. Van en variables de entorno o en un gestor de secretos, nunca en el repositorio.

Qué pasó con GPT_scraper

ChatGPT agregó poco después una exportación oficial, se mudó a chatgpt.com y sus servicios internos cambiaron. Hoy, para respaldar tu historial, el camino correcto es el oficial: Settings → Data controls → Export data. OpenAI te envía un enlace para descargar un archivo ZIP (guía de OpenAI).

El repositorio probablemente ya no funcione tal cual, y lo dejamos como material de estudio. Sus dos caminos siguen siendo la forma más clara de explicar cómo integrar un sistema que no fue pensado para integrarse.

Si en tu empresa alguien saca datos de un sistema copiando y pegando, ese sistema casi seguro tiene uno de estos dos caminos. Encontrar el correcto es la primera parte de nuestro diagnóstico.

Transcribir esos audios ya no requiere pagar un servicio por minuto ni subir conversaciones internas a la nube. Whisper, el modelo de reconocimiento de voz que OpenAI publicó como código abierto, corre en un computador de oficina y entiende bien el español. En este artículo te mostramos cómo usarlo con un script corto que probamos antes de publicar.

Por qué local y no un servicio en la nube

Hay servicios que transcriben muy bien. La pregunta es qué estás dispuesto a enviarles. Un audio de terreno puede mencionar fallas, nombres, clientes o montos. Una reunión de gerencia, todavía más. Con Whisper en tu equipo:

• El audio no sale de tu computador. Solo la primera vez se descarga el modelo; después funciona sin internet.
• No hay costo por minuto. Transcribir diez audios o diez mil cuesta lo mismo: el tiempo del computador.
• No dependes de una cuenta ni de un proveedor que cambie precios o condiciones.

El costo es la velocidad. En un computador sin tarjeta gráfica, un audio de un par de minutos tarda segundos o minutos según el modelo que elijas. Para la mayoría de los usos, eso basta.

Lo que necesitas

Usamos faster-whisper, una implementación de Whisper más rápida y liviana que la original. Tiene una ventaja práctica: decodifica el audio con PyAV, que trae incluido lo necesario, así que no tienes que instalar FFmpeg. Lee directamente los .ogg y .opus de las notas de voz de WhatsApp, además de .mp3, .m4a y .wav.

Crea un entorno virtual e instala la librería:

python -m venv .venv
source .venv/bin/activate    # en Windows: .venv\Scripts\activate
pip install faster-whisper

El script

Pon los audios en una carpeta llamada audios. El script los recorre en orden alfabético, transcribe cada uno y deja todo en un solo archivo de texto:

from pathlib import Path

from faster_whisper import WhisperModel

CARPETA = Path("audios")             # .ogg/.opus de WhatsApp, .mp3, .m4a, .wav...
SALIDA = Path("transcripciones.md")

modelo = WhisperModel("small", device="cpu", compute_type="int8")

with SALIDA.open("w", encoding="utf-8") as f:
    for audio in sorted(p for p in CARPETA.iterdir() if p.is_file()):
        segmentos, info = modelo.transcribe(str(audio), vad_filter=True)
        texto = " ".join(s.text.strip() for s in segmentos)
        f.write(f"## {audio.name} ({info.language})\n\n{texto}\n\n")
        print(f"Listo: {audio.name}")

Tres detalles que importan:

• compute_type="int8" reduce la memoria y acelera el trabajo en procesador, con una pérdida de calidad que en la práctica no se nota.
• vad_filter=True salta los silencios antes de transcribir. En audios de terreno, con pausas y ruido, evita frases inventadas en los tramos sin voz.
• El idioma se detecta solo y queda en info.language. Si todos tus audios son en español, puedes fijarlo con language="es" y ganar un poco de velocidad.

Lo probamos con dos audios: un reporte de terreno en .wav y los acuerdos de una reunión en .ogg, el formato de WhatsApp. Este fue el resultado, sin corregir nada:

## 01-reporte-terreno.wav (es)

Hola, te cuento cómo quedó la bomba del sector norte. Cambiamos el sello mecánico y quedó funcionando a las 4 de la tarde. Mañana hay que revisar la vibración.

## 02-reunion.ogg (es)

Acordamos tres cosas. Primero, el informe sale el viernes. Segundo, Carla revisa los costos. Tercero, la próxima reunión es el martes.

Si necesitas saber en qué minuto se dijo algo, cada segmento trae su inicio y su fin en segundos (s.start y s.end). Puedes escribir una línea por segmento en vez de unirlos.

Qué modelo elegir

El primer argumento de WhisperModel es el tamaño del modelo. Más grande es más preciso y más lento:

Si tienes una tarjeta gráfica NVIDIA, cambia a device="cuda" y compute_type="float16". La diferencia de velocidad es grande.

Del script al proceso

El script resuelve el caso de una persona con una carpeta de audios. En una empresa, lo valioso es que la transcripción llegue sola a donde se usa:

• Una carpeta compartida o un buzón de correo donde el equipo deja los audios, y una tarea que los transcribe cada pocos minutos.
• Un resumen con los acuerdos y los pendientes, preparado por un modelo de lenguaje que también puede correr en tu servidor.
• El texto cargado en el sistema que corresponde: la orden de trabajo, la ficha del cliente o el acta de la reunión.

Ahí la transcripción deja de ser un truco y se convierte en un registro: el técnico sigue reportando por audio, como le acomoda, y la jefatura tiene el texto listo para buscar y decidir.

Si en tu equipo los reportes llegan por audio y se pierden en el chat, cuéntanos cómo se hace hoy.