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, sign in, turn any site into a callable API, and crawl whole sites. Ask once and Writ builds and tests the API; every ask after calls it, at zero token cost.
A toolbelt for the whole web, not just the APIs.
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:
The same tools run in two places, always on your own accounts: Writ Desktop’s local writ server on your machine (32 tools, no account needed), and the writ-cloud server at api.usewrit.app/mcp for callers that are not on this machine. writ_search_api finds a ready-made marketplace API: called as is in the cloud, rebuilt locally on Desktop.
The keyless tier: no account, no key. Public pages only — which is exactly the limit worth knowing.
curl -X POST https://api.usewrit.app/v1/keyless/scrape \
-H "Content-Type: application/json" \
-H "X-Writ-Client-Id: my-device-1" \
-d '{"url":"https://example.com"}' { "url": "https://example.com",
"markdown": "# Example Domain\n…" }This page was public. For pages behind a login, run it with a persona. Keyless calls carry fair-use rate limits.
Point your assistant at Writ and it gets the whole toolbox — every saved workflow runs from it, and the ones you pin become their own tools.
claude mcp add writ-cloud \
-e WRIT_API_KEY=wt_your_api_key \
-- npx -y writ-mcp Config-file clients — Claude Desktop · Cursor · Windsurf
The base tools, plus one run_<name> tool per workflow you pin. The keyless tier needs no key at all to start.
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); 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 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) 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); Ask once, it builds it. Ask again, it calls it.
The first time you ask your agent for a reliable way to reach a site, Writ does the hard work once: opens a browser, works through the steps, tests the result and saves it as an API. Every ask after that calls the saved API: deterministic, never re-reasoned, free of token cost. Watch both halves:
The saved API is also a REST endpoint and MCP tool, so the same API your agent built is callable from your code, other agents, or a schedule. See Website → API and Automations.
Read-only crawlers stop at the page. Writ tools act.
An MCP server that just dumps page text cannot submit forms, update dashboards, trigger approved workflows, or pull data from behind a login. Writ packages the whole task, including authenticated, multi-step ones, as an MCP tool. Your agent calls a tool; Writ runs the API and returns structured output.
Read-only crawlers
- Return page text only
- No login or two-factor
- Cannot fill forms or click
- No multi-step tasks
- Unstructured output
Writ MCP tools
- Take real actions on the page
- Log in, pass TOTP and mailbox-OTP
- Fill forms, click, navigate
- Complete multi-step tasks
- Return typed, structured output
How a saved API becomes a tool
Every saved API is callable through writ_run_workflow. Pin one and the server lists it as its own run_<name> tool, with the API’s inputs as its typed schema and the description your agent reads to decide when to use it.
- 01
A saved API
Start from any API Writ built, rebuilt or recorded.
- 02
Pin it
One call to writ_pin_workflow_tool; the input schema comes from the API’s own inputs.
- 03
Listed on MCP
The cloud server at api.usewrit.app/mcp lists it as run_<name>; Writ Desktop’s writ server does the same on your machine.
- 04
Agent discovers & calls
Your agent picks the tool by its description and calls it.
writ_pin_workflow_tool({
"workflow": "price-check",
"pinned": true
})
→ run_price_check
listed on https://api.usewrit.app/mcpConnect it to your agent
Point any MCP-compatible client at the Writ server URL and authenticate with a wt_ key. Tools appear automatically; your agent picks them by description.
{
"mcpServers": {
"writ-cloud": {
"url": "https://api.usewrit.app/mcp",
"headers": { "Authorization": "Bearer wt_8f2c...a91" }
}
}
}Works with Claude, Cursor, ChatGPT and any MCP client. Authorize with a scoped wt_ key (or OAuth, where the client signs in); revoke or rotate it without touching the API.
Set it up where your agent lives
One page per client, with the exact config block and the steps that work today.
Tools that work on the hard web
Because each tool was built and tested on the live site, it handles login, TOTP and mailbox-OTP two-factor on your own authenticated accounts, dynamic pages, and 30+ step types. When a site moves, auto-repair rebuilds the broken step, and repairs are free.
Two-factor and login run on your own authenticated accounts; see Personas.
Authorized by design
Writ runs on your own accounts, with your own credentials and data, on sites you are authorized to use. It automates work a person could do by hand in a browser. Secrets live in an encrypted vault, tools are scoped by wt_ key, and every tool call is logged and attributable to a run.
See trust, security, and the acceptable use policy.
MCP FAQ
What is a Writ MCP tool?
A Writ MCP tool is an API Writ built from one sentence (a real browser only when the site needs one), exposed over the Model Context Protocol. It has a name, a description the agent reads to decide when to use it, a typed input schema, and a structured output. Unlike a read-only crawler, it takes real actions: login, forms, clicks, multi-step tasks.
Which MCP clients work with Writ?
Any MCP-compatible client. Point Claude, Cursor, ChatGPT or your own MCP client at the Writ server URL and authenticate with a scoped wt_ key (or sign in over OAuth where the client supports it). Tools appear automatically and the agent selects them by description.
Does it handle login and 2FA?
Yes. Because each tool was built on the live site, it handles login, TOTP and mailbox-OTP two-factor, dynamic pages, and 30+ step types, on your own authenticated accounts. Writ runs on your own accounts, with your own credentials and data, on sites you are authorized to use.
How is a Writ tool different from a read-only MCP server?
Most website-to-MCP tools only read page text. Writ tools act: they log in, fill forms, click, extract, and complete multi-step tasks, then return structured output. Your agent calls a tool; Writ runs the saved API.