T0 API documentation

# 1. create a session — comes from the warm pool, ready in well under a second
SESSION=$(curl -s -X POST https://api.t0.sikasio.com/v1/sessions \
  -H "Authorization: Bearer t0k_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name":"quickstart","model":"core"}' | jq -r .id)

# 2. push a file into its workspace
curl -X PUT https://api.t0.sikasio.com/v1/sessions/$SESSION/files/notes.md \
  -H "Authorization: Bearer t0k_live_YOUR_KEY" \
  --data-binary @notes.md

# 3. stream the events, then send a message from another shell
curl -N https://api.t0.sikasio.com/v1/sessions/$SESSION/events \
  -H "Authorization: Bearer t0k_live_YOUR_KEY" \
  -H "Accept: text/event-stream" &

curl -X POST https://api.t0.sikasio.com/v1/sessions/$SESSION/messages \
  -H "Authorization: Bearer t0k_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"content":"Summarise notes.md into summary.md, then run the tests."}'

# 4. take the result back out — works even after the session has gone to sleep
curl -s https://api.t0.sikasio.com/v1/sessions/$SESSION/files/summary.md \
  -H "Authorization: Bearer t0k_live_YOUR_KEY" \
  -o summary.md

// Node 18+ or any browser. Keep the key on a server you control.
const T0 = "https://api.t0.sikasio.com/v1";
const KEY = process.env.T0_API_KEY; // "t0k_live_YOUR_KEY"
const auth = { Authorization: "Bearer " + KEY };

// 1. create a session
const session = await fetch(T0 + "/sessions", {
  method: "POST",
  headers: { ...auth, "Content-Type": "application/json" },
  body: JSON.stringify({ name: "quickstart", model: "core" }),
}).then((r) => r.json());

// 2. push a file into its workspace
await fetch(T0 + "/sessions/" + session.id + "/files/notes.md", {
  method: "PUT",
  headers: { ...auth, "Content-Type": "text/markdown" },
  body: "# Notes\n\nShip the parser.",
});

// 3. open the event stream before sending the message
const events = await fetch(T0 + "/sessions/" + session.id + "/events", {
  headers: { ...auth, Accept: "text/event-stream" },
});
const reader = events.body.pipeThrough(new TextDecoderStream()).getReader();

await fetch(T0 + "/sessions/" + session.id + "/messages", {
  method: "POST",
  headers: { ...auth, "Content-Type": "application/json" },
  body: JSON.stringify({ content: "Summarise notes.md into summary.md." }),
});

for (;;) {
  const { value, done } = await reader.read();
  if (done) break;
  process.stdout.write(value);
}

import os, requests

T0 = "https://api.t0.sikasio.com/v1"
auth = {"Authorization": "Bearer " + os.environ["T0_API_KEY"]}

# 1. create a session
session = requests.post(
    T0 + "/sessions",
    headers=auth,
    json={"name": "quickstart", "model": "core"},
).json()
sid = session["id"]

# 2. push a file into its workspace
requests.put(
    T0 + "/sessions/" + sid + "/files/notes.md",
    headers={**auth, "Content-Type": "text/markdown"},
    data=b"# Notes\n\nShip the parser.",
)

# 3. send a message, then read the stream
requests.post(
    T0 + "/sessions/" + sid + "/messages",
    headers=auth,
    json={"content": "Summarise notes.md into summary.md."},
)

with requests.get(
    T0 + "/sessions/" + sid + "/events",
    headers={**auth, "Accept": "text/event-stream"},
    stream=True,
) as stream:
    for line in stream.iter_lines(decode_unicode=True):
        if line:
            print(line)

curl -X POST https://api.t0.sikasio.com/v1/sessions \
  -H "Authorization: Bearer t0k_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "invoice-parser",
    "model": "core",
    "idle_timeout": 600,
    "ttl": 86400,
    "env": { "NODE_ENV": "test" }
  }'

// Node 18+ or any browser. Keep the key on a server you control.
const T0 = "https://api.t0.sikasio.com/v1";
const KEY = process.env.T0_API_KEY; // "t0k_live_YOUR_KEY"
const auth = { Authorization: "Bearer " + KEY };

const session = await fetch(T0 + "/sessions", {
  method: "POST",
  headers: { ...auth, "Content-Type": "application/json" },
  body: JSON.stringify({
    name: "invoice-parser",
    model: "core",
    idle_timeout: 600,
    ttl: 86400,
    env: { NODE_ENV: "test" },
  }),
}).then((r) => r.json());

console.log(session.id, session.state, session.stream_url);

import os, requests

T0 = "https://api.t0.sikasio.com/v1"
auth = {"Authorization": "Bearer " + os.environ["T0_API_KEY"]}

session = requests.post(
    T0 + "/sessions",
    headers=auth,
    json={
        "name": "invoice-parser",
        "model": "core",
        "idle_timeout": 600,
        "ttl": 86400,
        "env": {"NODE_ENV": "test"},
    },
).json()

print(session["id"], session["state"], session["stream_url"])

curl -s "https://api.t0.sikasio.com/v1/sessions?limit=20" -H "Authorization: Bearer t0k_live_YOUR_KEY"

# next page
curl -s "https://api.t0.sikasio.com/v1/sessions?limit=20&cursor=c_9f21b0" -H "Authorization: Bearer t0k_live_YOUR_KEY"

// Node 18+ or any browser. Keep the key on a server you control.
const T0 = "https://api.t0.sikasio.com/v1";
const KEY = process.env.T0_API_KEY; // "t0k_live_YOUR_KEY"
const auth = { Authorization: "Bearer " + KEY };

let cursor;
do {
  const url = new URL(T0 + "/sessions");
  url.searchParams.set("limit", "20");
  if (cursor) url.searchParams.set("cursor", cursor);

  const page = await fetch(url, { headers: auth }).then((r) => r.json());
  for (const s of page.data) console.log(s.id, s.state, s.name);
  cursor = page.next_cursor;
} while (cursor);

import os, requests

T0 = "https://api.t0.sikasio.com/v1"
auth = {"Authorization": "Bearer " + os.environ["T0_API_KEY"]}

cursor = None
while True:
    params = {"limit": 20}
    if cursor:
        params["cursor"] = cursor

    page = requests.get(T0 + "/sessions", headers=auth, params=params).json()
    for s in page["data"]:
        print(s["id"], s["state"], s["name"])

    cursor = page.get("next_cursor")
    if not cursor:
        break

curl -s https://api.t0.sikasio.com/v1/sessions/sess_7f3a9c2e -H "Authorization: Bearer t0k_live_YOUR_KEY"

// Node 18+ or any browser. Keep the key on a server you control.
const T0 = "https://api.t0.sikasio.com/v1";
const KEY = process.env.T0_API_KEY; // "t0k_live_YOUR_KEY"
const auth = { Authorization: "Bearer " + KEY };

const session = await fetch(T0 + "/sessions/sess_7f3a9c2e", { headers: auth }).then((r) => r.json());

if (session.state === "sleeping") {
  console.log("asleep since", session.last_active_at, "— the next message wakes it");
}

import os, requests

T0 = "https://api.t0.sikasio.com/v1"
auth = {"Authorization": "Bearer " + os.environ["T0_API_KEY"]}

session = requests.get(T0 + "/sessions/sess_7f3a9c2e", headers=auth).json()

if session["state"] == "sleeping":
    print("asleep since", session["last_active_at"], "- the next message wakes it")

curl -X DELETE https://api.t0.sikasio.com/v1/sessions/sess_7f3a9c2e -H "Authorization: Bearer t0k_live_YOUR_KEY"

// Node 18+ or any browser. Keep the key on a server you control.
const T0 = "https://api.t0.sikasio.com/v1";
const KEY = process.env.T0_API_KEY; // "t0k_live_YOUR_KEY"
const auth = { Authorization: "Bearer " + KEY };

await fetch(T0 + "/sessions/sess_7f3a9c2e", { method: "DELETE", headers: auth });

import os, requests

T0 = "https://api.t0.sikasio.com/v1"
auth = {"Authorization": "Bearer " + os.environ["T0_API_KEY"]}

requests.delete(T0 + "/sessions/sess_7f3a9c2e", headers=auth)

curl -X POST https://api.t0.sikasio.com/v1/sessions/sess_7f3a9c2e/interrupt -H "Authorization: Bearer t0k_live_YOUR_KEY"

// Node 18+ or any browser. Keep the key on a server you control.
const T0 = "https://api.t0.sikasio.com/v1";
const KEY = process.env.T0_API_KEY; // "t0k_live_YOUR_KEY"
const auth = { Authorization: "Bearer " + KEY };

await fetch(T0 + "/sessions/sess_7f3a9c2e/interrupt", { method: "POST", headers: auth });

import os, requests

T0 = "https://api.t0.sikasio.com/v1"
auth = {"Authorization": "Bearer " + os.environ["T0_API_KEY"]}

requests.post(T0 + "/sessions/sess_7f3a9c2e/interrupt", headers=auth)

curl -X POST https://api.t0.sikasio.com/v1/sessions/sess_7f3a9c2e/messages \
  -H "Authorization: Bearer t0k_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Add a failing test for the invoice date parser, then make it pass.",
    "stream": true
  }'

// Node 18+ or any browser. Keep the key on a server you control.
const T0 = "https://api.t0.sikasio.com/v1";
const KEY = process.env.T0_API_KEY; // "t0k_live_YOUR_KEY"
const auth = { Authorization: "Bearer " + KEY };

const turn = await fetch(T0 + "/sessions/sess_7f3a9c2e/messages", {
  method: "POST",
  headers: { ...auth, "Content-Type": "application/json" },
  body: JSON.stringify({
    content: "Add a failing test for the invoice date parser, then make it pass.",
    stream: true,
  }),
}).then((r) => r.json());

console.log("turn", turn.turn_id, "accepted"); // 202 — output arrives on the stream

import os, requests

T0 = "https://api.t0.sikasio.com/v1"
auth = {"Authorization": "Bearer " + os.environ["T0_API_KEY"]}

turn = requests.post(
    T0 + "/sessions/sess_7f3a9c2e/messages",
    headers=auth,
    json={
        "content": "Add a failing test for the invoice date parser, then make it pass.",
        "stream": True,
    },
).json()

print("turn", turn["turn_id"], "accepted")  # 202 - output arrives on the stream

# -N disables curl's own buffering so deltas appear as they are produced
curl -N https://api.t0.sikasio.com/v1/sessions/sess_7f3a9c2e/events \
  -H "Authorization: Bearer t0k_live_YOUR_KEY" \
  -H "Accept: text/event-stream"

# reconnecting after a drop: resume from the last id you saw, nothing is lost
curl -N https://api.t0.sikasio.com/v1/sessions/sess_7f3a9c2e/events \
  -H "Authorization: Bearer t0k_live_YOUR_KEY" \
  -H "Accept: text/event-stream" \
  -H "Last-Event-ID: 128"

// Node 18+ or any browser. Keep the key on a server you control.
const T0 = "https://api.t0.sikasio.com/v1";
const KEY = process.env.T0_API_KEY; // "t0k_live_YOUR_KEY"
const auth = { Authorization: "Bearer " + KEY };

// EventSource cannot send an Authorization header, so read the stream with
// fetch. lastId is what makes a dropped connection resumable.
let lastId = null;

for (;;) {
  const headers = { ...auth, Accept: "text/event-stream" };
  if (lastId !== null) headers["Last-Event-ID"] = String(lastId);

  const res = await fetch(T0 + "/sessions/sess_7f3a9c2e/events", { headers });
  const reader = res.body.pipeThrough(new TextDecoderStream()).getReader();

  let buffer = "";
  try {
    for (;;) {
      const { value, done } = await reader.read();
      if (done) break;
      buffer += value;

      const frames = buffer.split("\n\n");
      buffer = frames.pop() ?? "";
      for (const frame of frames) {
        const id = frame.match(/^id: (.*)$/m)?.[1];
        const event = frame.match(/^event: (.*)$/m)?.[1];
        const data = frame.match(/^data: (.*)$/m)?.[1];
        if (id) lastId = id;
        if (event === "text.delta") process.stdout.write(JSON.parse(data).text);
        if (event === "turn.completed") console.log("\nusage", JSON.parse(data).usage);
      }
    }
  } catch {
    // fall through and reconnect from lastId
  }
}

import os, requests

T0 = "https://api.t0.sikasio.com/v1"
auth = {"Authorization": "Bearer " + os.environ["T0_API_KEY"]}

import json

last_id = None

while True:
    headers = {**auth, "Accept": "text/event-stream"}
    if last_id is not None:
        headers["Last-Event-ID"] = str(last_id)

    with requests.get(
        T0 + "/sessions/sess_7f3a9c2e/events", headers=headers, stream=True
    ) as stream:
        event = None
        for line in stream.iter_lines(decode_unicode=True):
            if line.startswith("id: "):
                last_id = line[4:]
            elif line.startswith("event: "):
                event = line[7:]
            elif line.startswith("data: "):
                payload = json.loads(line[6:])
                if event == "text.delta":
                    print(payload["text"], end="", flush=True)
                elif event == "turn.completed":
                    print("\nusage", payload["usage"])

# curl 8 speaks WebSocket; --no-buffer keeps frames unbuffered
curl --include --no-buffer \
  -H "Authorization: Bearer t0k_live_YOUR_KEY" \
  -H "Connection: Upgrade" \
  -H "Upgrade: websocket" \
  -H "Sec-WebSocket-Version: 13" \
  -H "Sec-WebSocket-Key: c2FtcGxlLWtleS0xMjM0NTY=" \
  https://api.t0.sikasio.com/v1/sessions/sess_7f3a9c2e/socket

// npm i ws  — a browser cannot set an Authorization header on a WebSocket,
// so proxy the socket from your own server, or use the SSE stream in the browser.
import WebSocket from "ws";

const socket = new WebSocket("wss://api.t0.sikasio.com/v1/sessions/sess_7f3a9c2e/socket", {
  headers: { Authorization: "Bearer " + process.env.T0_API_KEY },
});

socket.on("open", () => {
  socket.send(JSON.stringify({ type: "message", content: "Run the test suite." }));
});

socket.on("message", (raw) => {
  const event = JSON.parse(raw.toString());
  if (event.type === "text.delta") process.stdout.write(event.text);
  if (event.type === "turn.completed") socket.send(JSON.stringify({ type: "interrupt" }));
});

# pip install websockets
import asyncio, json, os, websockets

URL = "wss://api.t0.sikasio.com/v1/sessions/sess_7f3a9c2e/socket"
HEADERS = {"Authorization": "Bearer " + os.environ["T0_API_KEY"]}


async def main():
    async with websockets.connect(URL, additional_headers=HEADERS) as socket:
        await socket.send(json.dumps({"type": "message", "content": "Run the test suite."}))

        async for raw in socket:
            event = json.loads(raw)
            if event["type"] == "text.delta":
                print(event["text"], end="", flush=True)
            elif event["type"] == "turn.completed":
                await socket.send(json.dumps({"type": "interrupt"}))


asyncio.run(main())

curl -X PUT https://api.t0.sikasio.com/v1/sessions/sess_7f3a9c2e/files/src/parser.ts \
  -H "Authorization: Bearer t0k_live_YOUR_KEY" \
  -H "Content-Type: application/octet-stream" \
  --data-binary @src/parser.ts

// Node 18+ or any browser. Keep the key on a server you control.
const T0 = "https://api.t0.sikasio.com/v1";
const KEY = process.env.T0_API_KEY; // "t0k_live_YOUR_KEY"
const auth = { Authorization: "Bearer " + KEY };
import { readFile } from "node:fs/promises";

await fetch(T0 + "/sessions/sess_7f3a9c2e/files/src/parser.ts", {
  method: "PUT",
  headers: { ...auth, "Content-Type": "application/octet-stream" },
  body: await readFile("src/parser.ts"),
});

import os, requests

T0 = "https://api.t0.sikasio.com/v1"
auth = {"Authorization": "Bearer " + os.environ["T0_API_KEY"]}

with open("src/parser.ts", "rb") as fh:
    requests.put(
        T0 + "/sessions/sess_7f3a9c2e/files/src/parser.ts",
        headers={**auth, "Content-Type": "application/octet-stream"},
        data=fh,
    )

# whole trees go up as one tar.gz — one request instead of a thousand
tar czf - src package.json | curl -X POST https://api.t0.sikasio.com/v1/sessions/sess_7f3a9c2e/files \
  -H "Authorization: Bearer t0k_live_YOUR_KEY" \
  -H "Content-Type: application/gzip" \
  --data-binary @-

// Node 18+ or any browser. Keep the key on a server you control.
const T0 = "https://api.t0.sikasio.com/v1";
const KEY = process.env.T0_API_KEY; // "t0k_live_YOUR_KEY"
const auth = { Authorization: "Bearer " + KEY };
import { createReadStream } from "node:fs";

// tar the tree however you like, then stream the archive up in one request
await fetch(T0 + "/sessions/sess_7f3a9c2e/files", {
  method: "POST",
  headers: { ...auth, "Content-Type": "application/gzip" },
  body: createReadStream("project.tar.gz"),
  duplex: "half",
});

import os, requests

T0 = "https://api.t0.sikasio.com/v1"
auth = {"Authorization": "Bearer " + os.environ["T0_API_KEY"]}

import io, tarfile

buf = io.BytesIO()
with tarfile.open(fileobj=buf, mode="w:gz") as tar:
    tar.add("src")
    tar.add("package.json")

requests.post(
    T0 + "/sessions/sess_7f3a9c2e/files",
    headers={**auth, "Content-Type": "application/gzip"},
    data=buf.getvalue(),
)

# works while the session is asleep — served from the snapshot, no wake needed
curl -s https://api.t0.sikasio.com/v1/sessions/sess_7f3a9c2e/files/dist/report.pdf \
  -H "Authorization: Bearer t0k_live_YOUR_KEY" \
  -o report.pdf

// Node 18+ or any browser. Keep the key on a server you control.
const T0 = "https://api.t0.sikasio.com/v1";
const KEY = process.env.T0_API_KEY; // "t0k_live_YOUR_KEY"
const auth = { Authorization: "Bearer " + KEY };
import { writeFile } from "node:fs/promises";

const res = await fetch(T0 + "/sessions/sess_7f3a9c2e/files/dist/report.pdf", { headers: auth });
await writeFile("report.pdf", Buffer.from(await res.arrayBuffer()));

import os, requests

T0 = "https://api.t0.sikasio.com/v1"
auth = {"Authorization": "Bearer " + os.environ["T0_API_KEY"]}

res = requests.get(T0 + "/sessions/sess_7f3a9c2e/files/dist/report.pdf", headers=auth)
with open("report.pdf", "wb") as fh:
    fh.write(res.content)

curl -s "https://api.t0.sikasio.com/v1/sessions/sess_7f3a9c2e/files?path=/&recursive=true" -H "Authorization: Bearer t0k_live_YOUR_KEY"

// Node 18+ or any browser. Keep the key on a server you control.
const T0 = "https://api.t0.sikasio.com/v1";
const KEY = process.env.T0_API_KEY; // "t0k_live_YOUR_KEY"
const auth = { Authorization: "Bearer " + KEY };

const url = new URL(T0 + "/sessions/sess_7f3a9c2e/files");
url.searchParams.set("path", "/");
url.searchParams.set("recursive", "true");

const listing = await fetch(url, { headers: auth }).then((r) => r.json());
for (const entry of listing.files) console.log(entry.path, entry.bytes);

import os, requests

T0 = "https://api.t0.sikasio.com/v1"
auth = {"Authorization": "Bearer " + os.environ["T0_API_KEY"]}

listing = requests.get(
    T0 + "/sessions/sess_7f3a9c2e/files",
    headers=auth,
    params={"path": "/", "recursive": "true"},
).json()

for entry in listing["files"]:
    print(entry["path"], entry["bytes"])

curl -X DELETE https://api.t0.sikasio.com/v1/sessions/sess_7f3a9c2e/files/tmp/scratch.log -H "Authorization: Bearer t0k_live_YOUR_KEY"

// Node 18+ or any browser. Keep the key on a server you control.
const T0 = "https://api.t0.sikasio.com/v1";
const KEY = process.env.T0_API_KEY; // "t0k_live_YOUR_KEY"
const auth = { Authorization: "Bearer " + KEY };

await fetch(T0 + "/sessions/sess_7f3a9c2e/files/tmp/scratch.log", { method: "DELETE", headers: auth });

import os, requests

T0 = "https://api.t0.sikasio.com/v1"
auth = {"Authorization": "Bearer " + os.environ["T0_API_KEY"]}

requests.delete(T0 + "/sessions/sess_7f3a9c2e/files/tmp/scratch.log", headers=auth)

curl -s https://api.t0.sikasio.com/v1/me -H "Authorization: Bearer t0k_live_YOUR_KEY"

// Node 18+ or any browser. Keep the key on a server you control.
const T0 = "https://api.t0.sikasio.com/v1";
const KEY = process.env.T0_API_KEY; // "t0k_live_YOUR_KEY"
const auth = { Authorization: "Bearer " + KEY };

const me = await fetch(T0 + "/me", { headers: auth }).then((r) => r.json());
console.log(me.plan, me.limits.concurrent_sessions);

import os, requests

T0 = "https://api.t0.sikasio.com/v1"
auth = {"Authorization": "Bearer " + os.environ["T0_API_KEY"]}

me = requests.get(T0 + "/me", headers=auth).json()
print(me["plan"], me["limits"]["concurrent_sessions"])

curl -s "https://api.t0.sikasio.com/v1/usage?from=2026-08-01&to=2026-08-17" -H "Authorization: Bearer t0k_live_YOUR_KEY"

// Node 18+ or any browser. Keep the key on a server you control.
const T0 = "https://api.t0.sikasio.com/v1";
const KEY = process.env.T0_API_KEY; // "t0k_live_YOUR_KEY"
const auth = { Authorization: "Bearer " + KEY };

const url = new URL(T0 + "/usage");
url.searchParams.set("from", "2026-08-01");
url.searchParams.set("to", "2026-08-17");

const usage = await fetch(url, { headers: auth }).then((r) => r.json());
console.log(usage.credits_used, "of", usage.credits_included, "credits used");

import os, requests

T0 = "https://api.t0.sikasio.com/v1"
auth = {"Authorization": "Bearer " + os.environ["T0_API_KEY"]}

usage = requests.get(
    T0 + "/usage",
    headers=auth,
    params={"from": "2026-08-01", "to": "2026-08-17"},
).json()

print(usage["credits_used"], "of", usage["credits_included"], "credits used")

curl -s https://api.t0.sikasio.com/health

const health = await fetch("https://api.t0.sikasio.com/health").then((r) => r.json());
console.log(health.ok); // true — no key required

import requests

health = requests.get("https://api.t0.sikasio.com/health").json()
print(health["ok"])  # True - no key required

curl -s https://api.t0.sikasio.com/status

const status = await fetch("https://api.t0.sikasio.com/status").then((r) => r.json());
for (const component of status.components) console.log(component.name, component.status);

import requests

status = requests.get("https://api.t0.sikasio.com/status").json()
for component in status["components"]:
    print(component["name"], component["status"])