Watch the AI drive a live browser.

Open a live session and watch AI operate a real, logged-in browser turn by turn: read a page, fill a form, pull the result. Long-running runs you can watch and steer, with a separate tab per conversation.

A cold, per-call browser pays the login and warm-up tax on every request and loses its state. A live session authenticates once, stays logged in, and lets you watch and drive it turn by turn. Long, multi-step runs feel continuous.

Live session compared to cold per-call automation

Link a persona to a session and Writ applies it at start: the account identity, a consistent browser profile, and stored session state. Email and SMS one-time codes and TOTP are handled up front, so the AI lands on a page already logged in as you.

Define handlers on a live session and call them by name. Each handler is a unit of browser work you control (navigate, fill, extract, click through a multi-step flow), invoked on the warm, logged-in session. Handlers are deterministic: they do exactly what you defined, on the page state that's already there.

// Invoke a named handler on a warm, logged-in session.
POST /v1/streaming/{session}/handlers/extract_orders
Authorization: Bearer wt_...

{
  "since": "2026-06-01",
  "status": "shipped"
}

Point any OpenAI-compatible client at a Writ streaming session and chat with it like a model, except the "model" is a real browser acting on a real site. Each message lands in your own handler script — a JS handler you write — which drives the page and streams the reply. No AI model receives anything unless you put one in your handler. Use the SDKs and tools you already have; swap the base URL.

curl https://api.usewrit.app/v1/streaming/{session}/chat/completions \
  -H "Authorization: Bearer wt_..." \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      { "role": "user", "content": "Open the latest invoice and read the total." }
    ],
    "user": "conversation-7"
  }'

from openai import OpenAI

# Drop-in: bring your existing OpenAI client, swap the base URL.
client = OpenAI(
    base_url="https://api.usewrit.app/v1/streaming/{session}",
    api_key="wt_...",
)

resp = client.chat.completions.create(
    model="writ-browser",
    messages=[{"role": "user", "content": "Open the latest invoice and read the total."}],
    user="conversation-7",  # routes to its own browser tab
)
print(resp.choices[0].message.content)

Drop-in compatible: bring your existing OpenAI client and change the base URL. The browser acts on your own authenticated accounts; this is authorized-access automation, not circumvention.

Run several conversations against one session and each gets its own browser tab. Conversation state stays isolated; one chat's navigation and page context never bleed into another's. A stuck turn in one conversation can't wedge the others; turns are bounded and recoverable per tab.

Bring your own AI keys on a local/BYO agent and that AI is unbilled by Writ: you pay your provider directly, or run a local model for zero per-token cost. When a session uses managed cloud AI, you see real token usage per turn, the same numbers your provider would bill.

Streaming is how an AI agent operates a website as a living tool: keep a session warm, send it turns, watch each one, get structured results, hand it the next instruction. Combined with managed endpoints and MCP, your agent can call a Writ workflow as a tool and drive a live browser as a conversation, on sites that never shipped an API.

The Streaming surface: a live session, callable handlers, and the per-conversation tab strip.

Open a live session.

Watch AI drive a logged-in browser, and steer it turn by turn.