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 serveur MCP qui se contente de vider le texte d’une page ne peut ni soumettre des formulaires, ni mettre à jour des tableaux de bord, ni déclencher des workflows approuvés, ni extraire des données derrière une connexion. Writ empaquette des workflows de navigateur complets - y compris authentifiés et multi-étapes - sous forme d’outils MCP. Votre agent appelle un outil ; Writ exécute le vrai workflow et renvoie une sortie structurée.

Chaque serveur MCP Writ expose un ensemble d’outils. Un outil a un nom, une description que l’agent lit pour décider quand l’utiliser, un schéma d’entrée typé et une sortie structurée. Vous associez un workflow publié à un nom et une description d’outil dans la configuration de l’endpoint MCP - Writ l’annonce via le 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"
}

Pointez n’importe quel client compatible MCP vers l’URL de votre serveur Writ et authentifiez-vous avec une clé wt_. Les outils apparaissent automatiquement ; votre agent les choisit d’après leur description.

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

Parce que chaque outil est un véritable workflow de navigateur, il gère la connexion, la double authentification TOTP et OTP par boîte mail sur vos propres comptes authentifiés, les pages dynamiques et plus de 30 types d’étapes. Les recettes enregistrées associées à la navigation IA survivent aux changements d’interface, de sorte que les outils continuent de fonctionner quand les sites bougent.

La double authentification et la connexion s’exécutent sur vos propres comptes authentifiés - voir les Personas.

Writ s’exécute sur vos propres comptes, avec vos propres identifiants et données, sur des sites que vous êtes autorisé à utiliser. Il automatise un travail qu’une personne pourrait faire à la main dans un navigateur. Les secrets vivent dans un coffre-fort chiffré, les outils sont limités par clé wt_, et chaque appel d’outil est journalisé et attribuable à une exécution.

Voir confiance, sécurité, et la politique d’usage acceptable.