From a recording to a running endpoint.

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_CONSUMER_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com/product/42"}'

call.py

import os, requests

res = requests.post(
    "https://api.usewrit.app/v1/acme/price-check",
    headers={"Authorization": f"Bearer {os.environ['WRIT_CONSUMER_KEY']}"},  # csk_...
    json={"url": "https://example.com/product/42"},
    timeout=120,
)
res.raise_for_status()
payload = res.json()
print(payload["run_id"], payload["data"])

call.ts

const res = await fetch("https://api.usewrit.app/v1/acme/price-check", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.WRIT_CONSUMER_KEY}`, // csk_...
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ url: "https://example.com/product/42" }),
});

if (!res.ok) throw new Error(`Writ call failed: ${res.status}`);
const { run_id, data } = await res.json();
console.log(run_id, data);

call.go

package main

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

func main() {
	body, _ := json.Marshal(map[string]string{"url": "https://example.com/product/42"})
	req, _ := http.NewRequest("POST", "https://api.usewrit.app/v1/acme/price-check", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("WRIT_CONSUMER_KEY")) // csk_...
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	var out struct {
		RunID string          `json:"run_id"`
		Data  json.RawMessage `json:"data"`
	}
	json.NewDecoder(res.Body).Decode(&out)
	fmt.Println(out.RunID, string(out.Data))
}

call.rs

use serde_json::{json, Value};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let key = std::env::var("WRIT_CONSUMER_KEY")?; // csk_...
    let res: Value = reqwest::Client::new()
        .post("https://api.usewrit.app/v1/acme/price-check")
        .bearer_auth(key)
        .json(&json!({ "url": "https://example.com/product/42" }))
        .send()
        .await?
        .error_for_status()?
        .json()
        .await?;

    println!("{} {}", res["run_id"], res["data"]);
    Ok(())
}