Cualquier sitio. Detrás de cualquier login. Invocable.

Una sola llamada convierte un sitio en API. Writ revisa primero tus propios workflows y las opciones ya hechas — ambos gratis — y luego su agente conduce un navegador real y guarda el workflow. Consulta el id del build; lo que obtienes tiene su propio endpoint.

# One call. Writ's agent drives the browser and saves the workflow.
curl -X POST https://api.usewrit.app/api/v1/website-to-api \
  -H "Authorization: Bearer $WRIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://acme.example",
       "goal": "return a SKU'"'"'s price and stock"}'

{ "build_id": 2291,
  "status": "queued",
  "goal": "return a SKU's price and stock" }

⚠El slug existe porque publicaste ese workflow, y la clave es una clave de consumidor creada con él — no la clave de tu cuenta.

Una línea y el sitio se vuelve una API: di qué debe devolver y Writ abre un navegador real, descubre las llamadas detrás de la página y guarda el resultado como workflow.

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

# then, one line in the session:
writ_website_to_api({
  url:  "https://acme.example",
  goal: "return a SKU's price and stock",
})

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

El workflow guardado se convierte en su propia herramienta run_<name>, se repite sin coste de IA y puede programarse. ¿Prefieres REST? La pestaña cURL muestra el mismo inicio: POST /api/v1/website-to-api.

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

import { WritAgent, runRowId } from "@usewrit/agent-sdk";

const client = new WritAgent();              // discovers the running agent + token
const { data: workflows } = await client.workflows.list();
const run = await client.workflows.runAndWait(workflows[0].id, {
  inputs: { city: "Paris" },
});
const { data: rows } = await client.runs.data(runRowId(run));
console.log(run.status, rows);

Estos conducen el daemon LOCAL en tu máquina, donde las ejecuciones son gratuitas y no medidas. La pestaña cURL de arriba es el endpoint cloud publicado.

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

from writ_agent import WritAgent, run_row_id

with WritAgent() as client:                  # discovers the local daemon
    run = client.workflows.run_and_wait(3, inputs={"city": "Paris"})
    print(run["status"], run["rows_extracted"])
    print(client.runs.data(run_row_id(run))["data"])   # extracted rows

Estos conducen el daemon LOCAL en tu máquina, donde las ejecuciones son gratuitas y no medidas. La pestaña cURL de arriba es el endpoint cloud publicado.

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

client, err := writ.Discover(ctx)                        // find the running agent
page, _ := client.Workflows.List(ctx, nil)
item, _ := client.Workflows.RunAndWait(ctx, page.Data[0].ID, nil)
rowID, _ := item.RowID()
csv, _ := client.Runs.DataCSV(ctx, rowID)                // extracted rows as CSV
fmt.Println(item.Status, "
", csv)

Estos conducen el daemon LOCAL en tu máquina, donde las ejecuciones son gratuitas y no medidas. La pestaña cURL de arriba es el endpoint cloud publicado.

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

use writ_client::{RunOptions, WritAgent};

let agent = WritAgent::discover().await?;                // find the running daemon
let workflows = agent.workflows().list().await?;
let wf = &workflows.data[0];
let outcome = agent.workflows().run_and_wait(wf.id, &RunOptions::default()).await?;
let rows = agent.runs().data(outcome.run.row_id().unwrap()).await?;
println!("{} → {}: {}", wf.name, outcome.run.status, rows.data);

Estos conducen el daemon LOCAL en tu máquina, donde las ejecuciones son gratuitas y no medidas. La pestaña cURL de arriba es el endpoint cloud publicado.

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

Un rastreo de sitio completo es un solo POST con una clave. Writ reparte la semilla por la flota y entrega el resultado como un dataset invocable.

# No account, no key — a few same-domain pages, one level deep.
curl -X POST https://api.usewrit.app/v1/keyless/crawl \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com", "limit": 3}'

# With a key: the whole site, as a job you poll.
curl -X POST https://api.usewrit.app/api/crawl \
  -H "Authorization: Bearer $WRIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com", "max_depth": 3, "page_budget": 500}'

curl https://api.usewrit.app/api/crawl/8125 -H "Authorization: Bearer $WRIT_API_KEY"

⚠Sin cuenta para probarlo: el nivel sin clave rastrea unas pocas páginas del mismo dominio, un nivel de profundidad, con una asignación diaria. El alcance completo, los logins y un dataset invocable necesitan clave.

Apunta tu asistente a Writ y podrá rastrear un sitio directamente y luego leer las filas sin que escribas un parser.

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

# then, one line in the session:
writ_crawl_site({ url: "https://example.com",
                 intent: "product pages with specs",
                 page_budget: 500, save_as: "example-catalog" })

writ_crawl_status({ crawl_id: 8125 })

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

Con save_as el rastreo queda re-ejecutable e invocable: las siguientes ejecuciones reutilizan datos recientes en vez de volver a rastrear.

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

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

const cloud = new CloudApi({ apiKey: process.env.WRIT_API_KEY });
const job = await cloud.crawl({ url: "https://example.com", max_depth: 3, page_budget: 500 });
const status = await cloud.crawlStatus(job.id);
console.log(status.pages_done, "/", status.pages_discovered);

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"])
job = cloud.crawl("https://example.com", max_depth=3, page_budget=500)
status = cloud.crawl_status(job["id"])
print(status["pages_done"], "/", status["pages_discovered"])

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

client := writ.New(writ.WithAPIKey(os.Getenv("WRIT_API_KEY")))
job, err := client.Cloud.Crawl(ctx, writ.CrawlStartParams{
    URL:        "https://example.com",
    MaxDepth:   writ.Ptr(int64(3)),
    PageBudget: writ.Ptr(int64(500)),
})
status, _ := client.Cloud.CrawlStatus(ctx, job.ID)

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

use writ_client::{CloudClient, CrawlStartParams};

let cloud = CloudClient::from_env()?;
let job = cloud.crawl(&CrawlStartParams {
    url: "https://example.com".into(),
    max_depth: Some(3),
    page_budget: Some(500),
    ..Default::default()
}).await?;
let status = cloud.crawl_status(job.id).await?;