mon ▸ surveillance 00:00:00

Surveillez n’importe quelle page.
Agissez dès qu’elle bouge.

Pointez un moniteur sur n’importe quelle valeur d’une page : un prix, un statut, une zone visuelle, jusqu’à toutes les 10 secondes. Dès qu’elle change, Writ enchaîne dans la foulée : notifier un agent, appeler un webhook ou lancer un workflow.

Créer un moniteur Voir Watch-and-Act

jusqu’à toutes les 10 s · vos propres comptes et données · HTTP ou rendu navigateur complet

pricewatch/iphone-16-pro · toutes les 30 s

$1,199aucun changement pour l’instant

12 dernières vérifications · stable

détecter le changement→notifier l’agent→POST webhook→lancer le flux de reprix

✓ valeur, sélecteur ou zone visuelle✓ alertes uniquement en cas de changement✓ agir au changement

mon ▸ cible choisie 00:00:05

quoi surveiller

Un nombre, un élément ou toute une zone.

Prenez une référence sur une valeur, un sélecteur CSS ou une région de capture d’écran. Writ ne surveille que cela et ne vous prévient que lorsque ça change vraiment. Choisissez une cible :

store.example.com/iphone-16-provalue

pricewatch/iphone-16-pro 1× lecture par sélecteur

Notifier en dessous de

événementchange_detected

conditionprice < threshold

actionexécuter un workflow · notifier

La réaction part de la session déjà ouverte de la persona — pas de reconnexion à froid. Si l’action échoue, Writ journalise le run et applique la politique de reprise que vous avez configurée.

mon ▸ cadence réglée 00:00:11

cadence

Jusqu’à toutes les dix secondes.

Choisissez la fréquence de vérification. La cadence la plus rapide dépend de votre plan, et les vérifications HTTP légères tournent plus serré que les rendus navigateur plus lourds. Choisissez un intervalle :

prochaine vérification dans 05:00

mon ▸ changement détecté 00:00:18

surveiller et agir

Détectez le changement. Déclenchez l’action.

Quand un moniteur détecte un changement, cet événement devient un déclencheur d’automatisation : il lance un workflow, éventuellement retenu derrière une validation. De la détection à l’action, automatiquement. Essayez :

au changement → notifier · webhook · workflow

détecter le changement→notifier l’agent→POST webhook→lancer le workflow

Un changement est un déclencheur. Le déclencheur est une action, et il agit plus vite que vous ne le pourriez.

L’action est une automatisation qui lance un workflow. Voyez le schéma complet sur Watch-and-Act.

env ▸ lieu sélectionné 00:00:24

exécutez à votre façon

S’exécute sur votre machine, gratuitement, ou dans le cloud.

Les moniteurs locaux s’exécutent sur votre propre machine sans frais de calcul. Les moniteurs cloud tournent sur la flotte managée, vérifiés depuis la région de votre choix. Choisissez un lieu :

cadence ▸ par plan 00:00:26

Vérification la plus rapide, par offre

Une cadence honnête - sans astérisque.

La fréquence de vérification est un plancher fixe par offre. Les vérifications HTTP (pages statiques) sont plus rapides que les rendus JS (pages dynamiques), qui lancent un navigateur complet.

Offre	HTTP (statique)	Rendu JS (dynamique)
Free	toutes les 5 min	toutes les 15 min
Starter	toutes les 1 min	toutes les 10 min
Pro	toutes les 1 min	toutes les 10 min
Growth	toutes les 30 s	toutes les 5 min
Scale	toutes les 10 s	toutes les 2 min
Enterprise	toutes les 10 s	toutes les 2 min

Ces planchers sont les mêmes chiffres que sur la page tarifs - jamais un « contactez-nous » pour une cadence que nous affichons. La vérification toutes les 10 secondes est le plancher des paliers supérieurs.

rails ▸ actifs par défaut 00:00:28

Le rail en sept étapes

Une action sans surveillance, sur des rails que vous fixez.

Chaque déclenchement parcourt les sept mêmes étapes, dans l’ordre, et les étapes sensibles vous attendent. Rien n’agit directement depuis un changement de page.

01 détecter

DétecterUne vérification s’exécute à votre cadence et capture la nouvelle valeur. La détection seule ne déclenche rien.

02 valider

ValiderLa capture est extraite en valeurs structurées et dédupliquée - un changement réel ne se déclenche qu’une fois, même si plusieurs sélecteurs le détectent.

03 conditions

ConditionsVos règles tranchent : seuil, direction, délai de repos et un plafond strict sur la fréquence d’action. Pas de correspondance, pas d’action.

04 approbation

Approbation - si configuréeUne action verrouillée se met en attente d’approbation et vous notifie : approuver l’envoie, rejeter l’abandonne. Tout ce qui peut dépenser de l’argent vit aussi sous un plafond de dépense strict, et l’exécution à blanc répète toute la chaîne sans rien envoyer.

05 exécuter

ExécuterLe workflow s’exécute sur votre propre compte, sur des sites que vous êtes autorisé à utiliser. Les identifiants se résolvent depuis le coffre chiffré au moment de l’exécution - ils ne sont jamais écrits dans l’automatisation elle-même.

06 journaliser

JournaliserChaque déclenchement est enregistré - ce qui l’a déclenché, ce qui a tourné, le résultat et les horodatages - pour auditer exactement ce qui s’est passé, quand, et sur quel compte.

07 reprise

Réessayer - ou arrêterUne exécution échouée réessaie avec temporisation, sur un budget visible. Budget épuisé, la chaîne s’arrête au lieu de tirer à l’aveugle.

La détection tourne au plancher de cadence de votre offre - Free 5 min · Starter 1 min · Pro 1 min · Growth 30 s · Scale 10 s · Enterprise 10 s. Les mêmes planchers que sur la page tarifs, jamais réajustés ici à la main.

Une action verrouillée attend votre approbation explicite ; tout ce qui peut dépenser de l’argent vit aussi sous un plafond de dépense strict. Writ s’exécute sur vos propres comptes, avec vos propres identifiants, sur des sites que vous choisissez. Il automatise un travail qu’une personne pourrait faire à la main - dans des limites strictes, jamais au-delà. Consultez la politique d’usage acceptable.

cfg ▸ un seul fichier 00:00:31

Exemple

Du retour en stock à un workflow préparé - une seule configuration.

Le déclencheur, l’action et les garde-fous vivent dans une seule configuration. Appelez le Workflow obtenu comme un endpoint, ou laissez le changement le déclencher automatiquement.

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 des moniteurs 00:00:34

développeurs

Câblez les moniteurs depuis votre code.

Armez un moniteur via l’API dans n’importe quel langage : définissez la cible, la cadence et ce qui se déclenche au changement. Choisissez un langage et exécutez :

Un moniteur, c’est un seul POST avec une clé. Aucune installation, aucun agent à lancer — Writ vérifie la page à votre cadence et enregistre chaque changement.

# 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 intervalle inférieur au minimum de votre plan est refusé net, en nommant le plancher — il n’est jamais ralenti en silence.

Pointez votre assistant vers Writ et il peut créer et câbler les moniteurs lui-même — surveiller une page, puis déclencher une action quand elle bouge.

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"] })

Clients à fichier de config — Claude Desktop · Cursor · Windsurf

Les mêmes moniteurs apparaissent dans l’app, l’API et les SDK ; le lieu d’exécution change, le moniteur non.

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?;

Surveillez votre première page

Surveillez n’importe quelle page.Agissez dès qu’elle bouge.