Connect Writ.
Your agent gets hands on the web.

Add one MCP server and your AI agent can drive the real web: open a live browser, log in, turn any site into a callable API, record a workflow, and crawl whole sites at scale. Ask once and it builds the automation; ask again and it replays it instantly, at zero token cost.

Most agents can only call the handful of services that ship an API. Connected to Writ, yours can reach anything a person can open in a browser, on your own authorized accounts. Six capabilities, one server:

All six run on your machine, on your own accounts. No Writ AI key, no cloud account. Linking a free Writ Cloud account adds two more: writ_search_api / writ_install_api to find and install ready-made marketplace APIs, and public HTTPS endpoints for callers that aren't on this machine.

curl -X POST https://api.usewrit.app/api/crawl/scrape \
  -H "Content-Type: application/json" \
  -d '{"url":"https://example.com"}'

{ "url": "https://example.com",
  "markdown": "# Example Domain\n…" }

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

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

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

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)

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

The first time you ask your agent for a reliable way to drive a site, Writ does the hard work once: opens a browser, works through the steps, and saves the result as a workflow. Every ask after that skips straight to a replay: instant, deterministic, and free of token cost. Watch both halves:

The saved workflow is also a REST endpoint and MCP tool, so the same automation your agent built is callable from your code, other agents, or a schedule. See Website → API and Automations.

Un servidor MCP que solo vuelca el texto de una página no puede enviar formularios, actualizar paneles, disparar workflows aprobados ni extraer datos detrás de un inicio de sesión. Writ empaqueta workflows de navegador completos - incluidos los autenticados y multipaso - como herramientas MCP. Tu agente llama a una herramienta; Writ ejecuta el workflow real y devuelve una salida estructurada.

Cada servidor MCP de Writ expone un conjunto de herramientas. Una herramienta tiene un nombre, una descripción que el agente lee para decidir cuándo usarla, un esquema de entrada tipado y una salida estructurada. Asignas un workflow publicado a un nombre y una descripción de herramienta en la configuración del endpoint MCP - Writ lo anuncia a través del Model Context Protocol.

{
  "tool_name": "check_competitor_price",
  "tool_description": "Look up the current price and stock for a product URL.",
  "workflow_slug": "price-check",
  "server_version": "1.0.0"
}

Apunta cualquier cliente compatible con MCP a la URL de tu servidor de Writ y autentícate con una clave wt_. Las herramientas aparecen automáticamente; tu agente las elige por su descripción.

{
  "mcpServers": {
    "writ": {
      "url": "https://api.usewrit.app/mcp/acme",
      "headers": { "Authorization": "Bearer wt_8f2c...a91" }
    }
  }
}

Como cada herramienta es un workflow real de navegador, gestiona el inicio de sesión, el doble factor TOTP y OTP por buzón en tus propias cuentas autenticadas, las páginas dinámicas y más de 30 tipos de pasos. Las recetas grabadas junto con la navegación por IA sobreviven a los cambios de interfaz, así que las herramientas siguen funcionando cuando los sitios se mueven.

El doble factor y el inicio de sesión se ejecutan en tus propias cuentas autenticadas - mira las Personas.

Writ se ejecuta en tus propias cuentas, con tus propias credenciales y datos, en sitios que estás autorizado a usar. Automatiza un trabajo que una persona podría hacer a mano en un navegador. Los secretos viven en un almacén cifrado, las herramientas están acotadas por clave wt_, y cada llamada a una herramienta queda registrada y es atribuible a una ejecución.

Consulta confianza, seguridad, y la política de uso aceptable.