mon ▸ vigilando 00:00:00

Vigila cualquier página.
Actúa en cuanto se mueva.

Apunta un monitor a cualquier valor de cualquier página: un precio, un estado, una zona visual, tan rápido como cada 10 segundos. Cuando cambia, Writ actúa en el mismo compás: avisa a un agente, llama a un webhook o lanza un workflow.

Crear un monitor Ver Watch-and-Act

tan rápido como cada 10 s · tus propias cuentas y datos · HTTP o renderizado completo del navegador

pricewatch/iphone-16-pro · cada 30 s

$1,199sin cambios todavía

últimas 12 comprobaciones · estable

detectar el cambio→avisar al agente→POST webhook→lanzar el flujo de reprecio

✓ valor, selector o zona visual✓ avisos solo cuando cambia✓ actuar ante el cambio

mon ▸ objetivo elegido 00:00:05

qué vigilar

Un número, un elemento o toda una zona.

Toma una referencia sobre un valor, un selector CSS o una región de captura. Writ vigila solo eso y solo te avisa cuando de verdad cambia. Elige un objetivo:

store.example.com/iphone-16-provalue

pricewatch/iphone-16-pro 1× lectura por selector

Avisar por debajo de

eventochange_detected

condiciónprice < threshold

acciónejecutar workflow · notificar

La reacción parte de la sesión ya abierta de la persona — sin inicio en frío. Si la acción falla, Writ registra el run y aplica la política de reintentos que configuraste.

mon ▸ cadencia fijada 00:00:11

cadencia

Tan a menudo como cada diez segundos.

Elige con qué frecuencia comprueba el monitor. La cadencia más rápida la marca tu plan, y las comprobaciones HTTP ligeras van más apretadas que los renderizados de navegador. Elige un intervalo:

próxima comprobación en 05:00

mon ▸ cambio detectado 00:00:18

vigilar y actuar

Detecta el cambio. Dispara la acción.

Cuando un monitor detecta un cambio, ese evento se convierte en un disparador de automatización: lanza un workflow, opcionalmente retenido tras una validación. De la detección a la acción, automático. Pruébalo:

al cambiar → notificar · webhook · workflow

detectar el cambio→avisar al agente→POST webhook→lanzar el workflow

Un cambio es un disparador. El disparador es una acción, y ocurre más rápido de lo que tú podrías.

La acción es una automatización que lanza un workflow. Mira el patrón completo en Watch-and-Act.

env ▸ sede seleccionada 00:00:24

ejecútalo a tu manera

Se ejecuta en tu máquina, gratis, o en la nube.

Los monitores locales se ejecutan en tu propia máquina sin cargo de cómputo. Los monitores en la nube corren en la flota gestionada, comprobados desde la región que elijas. Elige dónde:

cadence ▸ por plan 00:00:26

Comprobación más rápida, por plan

Cadencia honesta - sin asteriscos.

La frecuencia de comprobación es un suelo fijo por plan. Las comprobaciones HTTP (páginas estáticas) son más rápidas que los renderizados JS (páginas dinámicas), que lanzan un navegador completo.

Plan	HTTP (estático)	Renderizado JS (dinámico)
Free	cada 5 min	cada 15 min
Starter	cada 1 min	cada 10 min
Pro	cada 1 min	cada 10 min
Growth	cada 30 s	cada 5 min
Scale	cada 10 s	cada 2 min
Enterprise	cada 10 s	cada 2 min

Estos suelos son las mismas cifras que en la página de precios - nunca un «contáctanos» para una cadencia que publicamos. La comprobación cada 10 segundos es el suelo de los planes superiores.

rails ▸ activos por defecto 00:00:28

El raíl de siete pasos

Acción desatendida, sobre raíles que tú fijas.

Cada disparo recorre los mismos siete pasos, en orden, y los pasos sensibles te esperan. Nada actúa directamente desde un cambio de página.

01 detectar

DetectarUna comprobación corre a tu cadencia y captura el nuevo valor. La detección por sí sola no dispara nada.

02 validar

ValidarLa captura se extrae en valores estructurados y se deduplica - un cambio real dispara una sola vez, aunque varios selectores lo detecten.

03 condiciones

CondicionesTus reglas deciden: umbral, dirección, tiempo de espera y un techo estricto de la frecuencia con la que puede actuar. Sin coincidencia, no hay acción.

04 aprobación

Aprobación - si está configuradaUna acción con puerta queda en espera de aprobación y te avisa: aprobar la envía, rechazar la descarta. Todo lo que pueda gastar dinero vive además bajo un tope de gasto estricto, y la ejecución en seco ensaya toda la cadena sin enviar nada.

05 ejecutar

EjecutarEl workflow corre en tu propia cuenta, en sitios que estás autorizado a usar. Las credenciales se resuelven desde la bóveda cifrada al ejecutarse - nunca se escriben dentro de la automatización.

06 registrar

RegistrarCada disparo queda registrado - qué lo disparó, qué corrió, el resultado y las marcas de tiempo - para auditar exactamente qué pasó, cuándo y en qué cuenta.

07 reintento

Reintentar - o pararUna ejecución fallida reintenta con espera creciente, sobre un presupuesto visible. Agotado el presupuesto, la cadena se detiene en vez de disparar a ciegas.

La detección corre al suelo de cadencia de tu plan - Free 5 min · Starter 1 min · Pro 1 min · Growth 30 s · Scale 10 s · Enterprise 10 s. Los mismos suelos que en la página de precios, nunca reajustados aquí a mano.

Una acción con puerta espera tu aprobación explícita; todo lo que pueda gastar dinero vive además bajo un tope de gasto estricto. Writ se ejecuta en tus propias cuentas, con tus propias credenciales, en los sitios que elijas. Automatiza un trabajo que una persona podría hacer a mano - dentro de límites estrictos, nunca más allá. Consulta la política de uso aceptable.

cfg ▸ una sola configuración 00:00:31

Ejemplo

De la vuelta a stock a un workflow preparado - una sola configuración.

El trigger, la acción y las barreras de seguridad viven en una sola configuración. Llama al Workflow resultante como un endpoint, o deja que el cambio lo dispare automáticamente.

watch-and-act.config

# Monitor: out-of-stock PDP, every 10s (Scale), JS render, selector ".stock-status"
# Automation: on change to "In stock" -> run Workflow "reserve-and-notify"
# Workflow: navigate -> fill (order form, Persona) -> submit -> capture confirmation
# Rails: confirm_gate=on, dry_run=false, rate_cap=1/min, idempotency_key=<sku+event>

POST https://api.usewrit.app/v1/reserve-and-notify/run
Authorization: Bearer wt_...
-> { "status": "awaiting_approval", "run_id": "...", "gate": "confirm-gate" }

dev ▸ api de monitores 00:00:34

desarrolladores

Cablea monitores desde el código.

Arma un monitor por la API en cualquier lenguaje: fija el objetivo, la cadencia y qué se dispara al cambiar. Elige un lenguaje y ejecútalo:

Un monitor es un solo POST con una clave. Sin instalación, sin agente que arrancar — Writ revisa la página a tu cadencia y registra cada cambio.

# Watch a page on Writ Cloud — no install, just the key.
curl -X POST https://api.usewrit.app/api/targets \
  -H "Authorization: Bearer $WRIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com",
       "check_type": "content",
       "selector": "h1",
       "check_period_ms": 300000}'

Un intervalo por debajo del mínimo de tu plan se rechaza sin más, nombrando el límite — nunca se ralentiza en silencio.

Apunta tu asistente a Writ y podrá crear y cablear monitores por su cuenta — vigilar una página y ejecutar algo cuando cambie.

claude mcp add writ-cloud \
  -e WRIT_API_KEY=wt_your_api_key \
  -- npx -y writ-mcp

# then, one line in the session:
writ_create_monitor({ url: "https://example.com",
                      selector: "h1", interval_minutes: 5 })

writ_wire_monitor({ monitor_id: 47, action: "notify",
                    channels: ["email"] })

Clientes con archivo de config — Claude Desktop · Cursor · Windsurf

Los mismos monitores aparecen en la app, la API y los SDK; cambia dónde corre, no el monitor.

npm install github:usewrit/writ-sdks --workspace typescript

import { CloudApi } from "@usewrit/agent-sdk";

const cloud = new CloudApi({ apiKey: process.env.WRIT_API_KEY });  // wt_…
const mon = await cloud.monitors.create({
  url: "https://example.com",
  selector: "h1",
  check_period_ms: 300_000,
});
const changes = await cloud.monitors.changes(mon.id, { limit: 50 });

pip install "git+https://github.com/usewrit/writ-sdks#subdirectory=python"

from writ_agent import Cloud

cloud = Cloud(api_key=os.environ["WRIT_API_KEY"])   # wt_… — no daemon needed
mon = cloud.monitors.create({
    "url": "https://example.com",
    "selector": "h1",
    "check_period_ms": 300_000,
})
changes = cloud.monitors.changes(mon["id"], limit=50)

go get github.com/usewrit/writ-sdks/go

client := writ.New(writ.WithAPIKey(os.Getenv("WRIT_API_KEY")))
mon, err := client.Cloud.Monitors.Create(ctx, writ.CloudMonitorParams{
    URL:           "https://example.com",
    Selector:      writ.Ptr("h1"),
    CheckPeriodMs: writ.Ptr(int64(300_000)),
})
changes, _ := client.Cloud.Monitors.Changes(ctx, mon.ID, writ.Ptr(50))

cargo add writ-client --git https://github.com/usewrit/writ-sdks

use serde_json::json;
use writ_client::CloudClient;

let cloud = CloudClient::from_env()?;                // reads WRIT_API_KEY
let mon = cloud.monitors().create(json!({
    "url": "https://example.com",
    "selector": "h1",
    "check_period_ms": 300_000
})).await?;
let changes = cloud.monitors().changes(mon.id, Some(50)).await?;

Vigila tu primera página

Vigila cualquier página.Actúa en cuanto se mueva.