Quatre SDKs. Un agent.

run.ts

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

run.py

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

run.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)

run.rs

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

call.sh

curl -X POST https://api.usewrit.app/v1/acme/price-check \
  -H "Authorization: Bearer $WRIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com/product/42"}'

events.ts

for await (const ev of client.runs.events(runRowId(run))) {
  console.log(ev.type, ev);
}

events.py

for ev in client.runs.events(run_row_id(run)):
    print(ev["type"], ev)

events.go

for ev, err := range client.Runs.Events(ctx, rowID) {
    if err != nil { break }
    fmt.Println(ev.Type, ev)
}

events.rs

use futures_util::StreamExt;
use writ_client::RunEvent;

let mut events = agent.runs().events(run_id).await?;
while let Some(ev) = events.next().await {
    match ev? {
        RunEvent::Step { index, step_type, status, .. } => println!("{index} {step_type} {status}"),
        RunEvent::Finished { status, .. } => println!("done: {status}"),
        _ => {}
    }
}

cloud.ts

const cloud = new CloudApi({ apiKey: process.env.WRIT_API_KEY }); // wt_…
const page = await cloud.scrape("https://example.com");
const site = await cloud.map("https://example.com", { search: "pricing", limit: 20 });
console.log(cloud.tier); // "metered" | "keyless"

cloud.py

cloud = Cloud(api_key=os.environ["WRIT_API_KEY"])  # wt_… — no daemon needed
page = cloud.scrape("https://example.com")
site = cloud.map("https://example.com", search="pricing", limit=20)
print(cloud.tier)  # "metered" | "keyless"

metered.sh

# Metered — wt_ API key, billed from your credit pool
curl -X POST https://api.usewrit.app/api/crawl/scrape \
  -H "Authorization: Bearer $WRIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com"}'

keyless.sh

# Keyless — no account, no key: a stable device id is the only identity.
# 429 keyless_rate_limited when the allowance is spent.
curl -X POST https://api.usewrit.app/v1/keyless/scrape \
  -H "X-Writ-Client-Id: $WRIT_CLIENT_ID" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com"}'
curl https://api.usewrit.app/v1/keyless/quota -H "X-Writ-Client-Id: $WRIT_CLIENT_ID"

const key = await client.keys.create({ name: "ci-runner", scopes: "read,run" });

key = client.keys.create("ci-runner", scopes="read,run")

key, err := client.Keys.Create(ctx, "ci-runner", "read,run")

let key = agent.keys().create("ci-runner", Some("read,run")).await?;

# Minting keys requires the full-access runtime token (wlt_)
curl -X POST http://127.0.0.1:8131/v1/keys \
  -H "Authorization: Bearer $WRIT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name": "ci-runner", "scopes": "read,run"}'

writ.py

import os, requests

WRIT_BASE = "https://api.usewrit.app"

def run_workflow(slug: str, path: str, inputs: dict) -> dict:
    res = requests.post(
        f"{WRIT_BASE}/v1/{slug}/{path}",
        headers={"Authorization": f"Bearer {os.environ['WRIT_CONSUMER_KEY']}"},
        json=inputs,
        timeout=120,
    )
    res.raise_for_status()
    return res.json()

payload = run_workflow("acme", "price-check", {"url": "https://example.com/product/42"})
print(payload["data"])

writ.ts

const WRIT_BASE = "https://api.usewrit.app";

export async function runWorkflow<T>(slug: string, path: string, inputs: unknown): Promise<T> {
  const res = await fetch(`${WRIT_BASE}/v1/${slug}/${path}`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.WRIT_CONSUMER_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify(inputs),
  });
  if (!res.ok) throw new Error(`Writ ${res.status}: ${await res.text()}`);
  return res.json() as Promise<T>;
}

writ.go

package writ

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

const Base = "https://api.usewrit.app"

func RunWorkflow(slug, path string, inputs any) (map[string]any, error) {
	body, err := json.Marshal(inputs)
	if err != nil {
		return nil, err
	}
	req, _ := http.NewRequest("POST", fmt.Sprintf("%s/v1/%s/%s", Base, slug, path), bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("WRIT_CONSUMER_KEY"))
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()
	if res.StatusCode >= 400 {
		return nil, fmt.Errorf("writ %d", res.StatusCode)
	}
	var out map[string]any
	return out, json.NewDecoder(res.Body).Decode(&out)
}

writ.rs

use serde::Serialize;
use serde_json::Value;

pub const BASE: &str = "https://api.usewrit.app";

pub async fn run_workflow<T: Serialize>(
    slug: &str,
    path: &str,
    inputs: &T,
) -> Result<Value, Box<dyn std::error::Error>> {
    let key = std::env::var("WRIT_CONSUMER_KEY")?;
    Ok(reqwest::Client::new()
        .post(format!("{BASE}/v1/{slug}/{path}"))
        .bearer_auth(key)
        .json(inputs)
        .send()
        .await?
        .error_for_status()?
        .json()
        .await?)
}

run.sh

# WRIT_CONSUMER_KEY must be exported (csk_...)
curl -sS -X POST https://api.usewrit.app/v1/acme/price-check \
  -H "Authorization: Bearer $WRIT_CONSUMER_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com/product/42"}' | jq .data