Experiment Desk — API

BASE="https://api.skillsafe.ai/v1/app-api"
TOKEN="YOUR_TOKEN"

call() {   # call <path> <json-body>
  curl -sS -X POST "$BASE$1" \
    -H "Authorization: Bearer $TOKEN" \
    -H "Content-Type: application/json" \
    -d "$2"
}

import json, os, urllib.request

BASE = "https://api.skillsafe.ai/v1/app-api"
TOKEN = os.environ.get("SKILLSAFE_TOKEN", "YOUR_TOKEN")

def call(path, body=None, method="POST"):
    data = json.dumps(body).encode() if body is not None else None
    req = urllib.request.Request(BASE + path, data=data, method=method)
    req.add_header("Authorization", "Bearer " + TOKEN)
    req.add_header("Content-Type", "application/json")
    with urllib.request.urlopen(req) as r:
        env = json.load(r)
    if not env.get("ok"):
        raise RuntimeError(env["error"]["code"] + ": " + env["error"]["message"])
    return env["data"]

const BASE = "https://api.skillsafe.ai/v1/app-api";
const TOKEN = "YOUR_TOKEN";

async function call(path, body, method = "POST") {
  const res = await fetch(BASE + path, {
    method,
    headers: {
      "Authorization": `Bearer ${TOKEN}`,
      "Content-Type": "application/json"
    },
    body: body === undefined ? undefined : JSON.stringify(body)
  });
  const env = await res.json();
  if (!env.ok) throw new Error(`${env.error.code}: ${env.error.message}`);
  return env.data;
}

package main

import (
    "bytes"
    "encoding/json"
    "errors"
    "net/http"
)

const base = "https://api.skillsafe.ai/v1/app-api"
const token = "YOUR_TOKEN"

type envelope struct {
    OK    bool            `json:"ok"`
    Data  json.RawMessage `json:"data"`
    Error *struct {
        Code    string `json:"code"`
        Message string `json:"message"`
    } `json:"error"`
}

func call(path string, body any) (json.RawMessage, error) {
    b, _ := json.Marshal(body)
    req, _ := http.NewRequest("POST", base+path, bytes.NewReader(b))
    req.Header.Set("Authorization", "Bearer "+token)
    req.Header.Set("Content-Type", "application/json")
    res, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer res.Body.Close()
    var env envelope
    if err := json.NewDecoder(res.Body).Decode(&env); err != nil {
        return nil, err
    }
    if !env.OK {
        return nil, errors.New(env.Error.Code + ": " + env.Error.Message)
    }
    return env.Data, nil
}

import java.net.URI;
import java.net.http.*;

public class TamDesk {
    static final String BASE = "https://api.skillsafe.ai/v1/app-api";
    static final String TOKEN = "YOUR_TOKEN";
    static final HttpClient HTTP = HttpClient.newHttpClient();

    static String call(String path, String jsonBody) throws Exception {
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create(BASE + path))
            .header("Authorization", "Bearer " + TOKEN)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
            .build();
        HttpResponse<String> res = HTTP.send(req, HttpResponse.BodyHandlers.ofString());
        return res.body();   // a JSON envelope: { ok, data } or { ok, error }
    }
}

require "json"
require "net/http"

BASE  = "https://api.skillsafe.ai/v1/app-api"
TOKEN = "YOUR_TOKEN"

def call(path, body = nil, method = :post)
  uri = URI(BASE + path)
  klass = method == :get ? Net::HTTP::Get : Net::HTTP::Post
  req = klass.new(uri)
  req["Authorization"] = "Bearer #{TOKEN}"
  req["Content-Type"]  = "application/json"
  req.body = JSON.dump(body) if body
  res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
  env = JSON.parse(res.body)
  raise "#{env["error"]["code"]}: #{env["error"]["message"]}" unless env["ok"]
  env["data"]
end

<?php
const BASE  = "https://api.skillsafe.ai/v1/app-api";
const TOKEN = "YOUR_TOKEN";

function call(string $path, ?array $body = null, string $method = "POST") {
    $ch = curl_init(BASE . $path);
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CUSTOMREQUEST  => $method,
        CURLOPT_HTTPHEADER     => [
            "Authorization: Bearer " . TOKEN,
            "Content-Type: application/json",
        ],
    ]);
    if ($body !== null) {
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($body));
    }
    $env = json_decode(curl_exec($ch), true);
    curl_close($ch);
    if (empty($env["ok"])) {
        throw new RuntimeException($env["error"]["code"] . ": " . $env["error"]["message"]);
    }
    return $env["data"];
}

using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;

var BASE = "https://api.skillsafe.ai/v1/app-api";
var TOKEN = "YOUR_TOKEN";

var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", TOKEN);

async Task<JsonElement> Call(string path, object? body = null)
{
    var content = new StringContent(JsonSerializer.Serialize(body ?? new { }),
                                    Encoding.UTF8, "application/json");
    var res = await http.PostAsync(BASE + path, content);
    var env = JsonDocument.Parse(await res.Content.ReadAsStringAsync()).RootElement;
    if (!env.GetProperty("ok").GetBoolean())
        throw new Exception(env.GetProperty("error").GetProperty("code").GetString());
    return env.GetProperty("data");
}

curl -sS -X POST "$BASE/guest" \
  -H "Content-Type: application/json" \
  -d '{"slug":"experiment-desk"}'
# -> { "ok": true, "data": { "token": "...", "subject_type": "guest" } }

import json, urllib.request

req = urllib.request.Request(
    "https://api.skillsafe.ai/v1/app-api/guest",
    data=json.dumps({"slug": "experiment-desk"}).encode(),
    headers={"Content-Type": "application/json"},
)
with urllib.request.urlopen(req) as r:
    TOKEN = json.load(r)["data"]["token"]

const res = await fetch("https://api.skillsafe.ai/v1/app-api/guest", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ slug: "experiment-desk" })
});
const { data } = await res.json();
const TOKEN = data.token;

body := bytes.NewBufferString(`{"slug":"experiment-desk"}`)
res, _ := http.Post(base+"/guest", "application/json", body)
defer res.Body.Close()
var env struct {
    Data struct{ Token string } `json:"data"`
}
json.NewDecoder(res.Body).Decode(&env)
guestToken := env.Data.Token

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create(BASE + "/guest"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString("{\"slug\":\"experiment-desk\"}"))
    .build();
String envelope = HTTP.send(req, HttpResponse.BodyHandlers.ofString()).body();
// envelope.data.token

uri = URI("https://api.skillsafe.ai/v1/app-api/guest")
res = Net::HTTP.post(uri, JSON.dump({ slug: "experiment-desk" }),
                     "Content-Type" => "application/json")
TOKEN = JSON.parse(res.body)["data"]["token"]

<?php
$ch = curl_init("https://api.skillsafe.ai/v1/app-api/guest");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => ["Content-Type: application/json"],
    CURLOPT_POSTFIELDS     => json_encode(["slug" => "experiment-desk"]),
]);
$env = json_decode(curl_exec($ch), true);
$token = $env["data"]["token"];

var guestBody = new StringContent("{\"slug\":\"experiment-desk\"}", Encoding.UTF8, "application/json");
var guestRes = await new HttpClient().PostAsync(
    "https://api.skillsafe.ai/v1/app-api/guest", guestBody);
var guestEnv = JsonDocument.Parse(await guestRes.Content.ReadAsStringAsync()).RootElement;
var token = guestEnv.GetProperty("data").GetProperty("token").GetString();

curl -sS "$BASE/me" -H "Authorization: Bearer $TOKEN"
# -> { "ok": true, "data": { "subject_type": "user", "credits": 250000 } }

me = call("/me", method="GET")
print(me["subject_type"], me["credits"])

const me = await call("/me", undefined, "GET");
console.log(me.subject_type, me.credits);

req, _ := http.NewRequest("GET", base+"/me", nil)
req.Header.Set("Authorization", "Bearer "+token)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()

HttpRequest me = HttpRequest.newBuilder()
    .uri(URI.create(BASE + "/me"))
    .header("Authorization", "Bearer " + TOKEN)
    .GET()
    .build();
System.out.println(HTTP.send(me, HttpResponse.BodyHandlers.ofString()).body());

me = call("/me", nil, :get)
puts me["subject_type"], me["credits"]

<?php
$me = call("/me", null, "GET");
echo $me["subject_type"], " ", $me["credits"], PHP_EOL;

var meReq = new HttpRequestMessage(HttpMethod.Get, BASE + "/me");
var meRes = await http.SendAsync(meReq);
Console.WriteLine(await meRes.Content.ReadAsStringAsync());

curl -sS -X POST "$BASE/estimate" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  --data @input.json
# -> { "ok": true, "data": { "model": "gpt-5.6-terra", "model_alias": "gpt-terra",
#                            "markup_bps": 1000, "hold_credits": 2900, "min_credits": 120 } }

est = call("/estimate", payload)
print(est["model"], est["model_alias"], est["markup_bps"])
if me["credits"] < est["min_credits"]:
    raise SystemExit("top up before running")

const est = await call("/estimate", payload);
if (me.credits < est.min_credits) throw new Error("top up before running");
console.log(`reserving up to ${est.hold_credits} credits on ${est.model}`);

data, err := call("/estimate", payload)
if err != nil {
    log.Fatal(err)
}
var est struct {
    Model       string `json:"model"`
    HoldCredits int    `json:"hold_credits"`
    MinCredits  int    `json:"min_credits"`
}
json.Unmarshal(data, &est)

String est = call("/estimate", inputJson);
System.out.println(est);   // model, model_alias, markup_bps, hold_credits, min_credits

est = call("/estimate", payload)
abort("top up before running") if me["credits"] < est["min_credits"]
puts "reserving up to #{est["hold_credits"]} on #{est["model"]}"

<?php
$est = call("/estimate", $payload);
if ($me["credits"] < $est["min_credits"]) {
    exit("top up before running\n");
}

var est = await Call("/estimate", payload);
Console.WriteLine(est.GetProperty("model").GetString());
Console.WriteLine(est.GetProperty("hold_credits").GetInt32());

curl -sS -X POST "$BASE/run" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: experiment-desk:00328e8c:1358:a1" \
  --data @input.json
# -> { "ok": true, "data": { "job_id": "job_...", "status": "queued" } }

curl -sS "$BASE/jobs/job_..." -H "Authorization: Bearer $TOKEN"
# poll until status is "succeeded" or "failed"

import time

req = urllib.request.Request(BASE + "/run", data=json.dumps(payload).encode(), method="POST")
req.add_header("Authorization", "Bearer " + TOKEN)
req.add_header("Content-Type", "application/json")
req.add_header("Idempotency-Key", "experiment-desk:00328e8c:1358:a1")
with urllib.request.urlopen(req) as r:
    job = json.load(r)["data"]

while True:
    j = call("/jobs/" + job["job_id"], method="GET")
    if j["status"] in ("succeeded", "failed"):
        break
    time.sleep(1.5)

result = json.loads(j["output"]["output"])
print(len(result["metric_reviews"]), "metric readings")

const job = await fetch(`${BASE}/run`, {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${TOKEN}`,
    "Content-Type": "application/json",
    "Idempotency-Key": "experiment-desk:00328e8c:1358:a1"
  },
  body: JSON.stringify(payload)
}).then(r => r.json()).then(e => e.data);

let j;
do {
  await new Promise(r => setTimeout(r, 1500));
  j = await call(`/jobs/${job.job_id}`, undefined, "GET");
} while (j.status !== "succeeded" && j.status !== "failed");

const result = JSON.parse(j.output.output);

b, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", base+"/run", bytes.NewReader(b))
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Idempotency-Key", "experiment-desk:00328e8c:1358:a1")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
// then poll GET /jobs/{job_id} until status is terminal

HttpRequest run = HttpRequest.newBuilder()
    .uri(URI.create(BASE + "/run"))
    .header("Authorization", "Bearer " + TOKEN)
    .header("Content-Type", "application/json")
    .header("Idempotency-Key", "experiment-desk:00328e8c:1358:a1")
    .POST(HttpRequest.BodyPublishers.ofString(inputJson))
    .build();
String job = HTTP.send(run, HttpResponse.BodyHandlers.ofString()).body();
// then poll GET /jobs/{job_id}

uri = URI(BASE + "/run")
req = Net::HTTP::Post.new(uri)
req["Authorization"]   = "Bearer #{TOKEN}"
req["Content-Type"]    = "application/json"
req["Idempotency-Key"] = "experiment-desk:00328e8c:1358:a1"
req.body = JSON.dump(payload)
job = JSON.parse(Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }.body)["data"]

loop do
  j = call("/jobs/#{job["job_id"]}", nil, :get)
  break if %w[succeeded failed].include?(j["status"])
  sleep 1.5
end

<?php
$ch = curl_init(BASE . "/run");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        "Authorization: Bearer " . TOKEN,
        "Content-Type: application/json",
        "Idempotency-Key: experiment-desk:00328e8c:1358:a1",
    ],
    CURLOPT_POSTFIELDS     => json_encode($payload),
]);
$job = json_decode(curl_exec($ch), true)["data"];
// then poll GET /jobs/{job_id}

var runMsg = new HttpRequestMessage(HttpMethod.Post, BASE + "/run")
{
    Content = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json")
};
runMsg.Headers.Add("Idempotency-Key", "experiment-desk:00328e8c:1358:a1");
var runRes = await http.SendAsync(runMsg);
// then poll GET /jobs/{job_id}

curl -N -sS -X POST "$BASE/run-stream" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: experiment-desk:00328e8c:1358:a1" \
  --data @input.json

# event: job
# data: {"job_id":"job_..."}
# event: delta
# data: {"text":"{\"title\":\"Checkout single-page test"}
# event: done
# data: {"status":"succeeded","charged_credits":812,"truncated":false}

req = urllib.request.Request(BASE + "/run-stream", data=json.dumps(payload).encode())
req.add_header("Authorization", "Bearer " + TOKEN)
req.add_header("Content-Type", "application/json")
req.add_header("Idempotency-Key", "experiment-desk:00328e8c:1358:a1")

raw, event = "", None
with urllib.request.urlopen(req) as r:
    for line in r:
        line = line.decode().rstrip("\n")
        if line.startswith("event:"):
            event = line[6:].strip()
        elif line.startswith("data:") and event == "delta":
            raw += json.loads(line[5:])["text"]

result = json.loads(raw)

const res = await fetch(`${BASE}/run-stream`, {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${TOKEN}`,
    "Content-Type": "application/json",
    "Idempotency-Key": "experiment-desk:00328e8c:1358:a1"
  },
  body: JSON.stringify(payload)
});

const reader = res.body.getReader();
const dec = new TextDecoder();
let buf = "", raw = "", event = null;
for (;;) {
  const { done, value } = await reader.read();
  if (done) break;
  buf += dec.decode(value, { stream: true });
  const lines = buf.split("\n");
  buf = lines.pop();
  for (const line of lines) {
    if (line.startsWith("event:")) event = line.slice(6).trim();
    else if (line.startsWith("data:") && event === "delta") raw += JSON.parse(line.slice(5)).text;
  }
}
const result = JSON.parse(raw);

req, _ := http.NewRequest("POST", base+"/run-stream", bytes.NewReader(b))
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Idempotency-Key", "experiment-desk:00328e8c:1358:a1")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()

sc := bufio.NewScanner(res.Body)
var event, raw string
for sc.Scan() {
    line := sc.Text()
    switch {
    case strings.HasPrefix(line, "event:"):
        event = strings.TrimSpace(line[6:])
    case strings.HasPrefix(line, "data:") && event == "delta":
        var d struct{ Text string }
        json.Unmarshal([]byte(line[5:]), &d)
        raw += d.Text
    }
}

HttpRequest stream = HttpRequest.newBuilder()
    .uri(URI.create(BASE + "/run-stream"))
    .header("Authorization", "Bearer " + TOKEN)
    .header("Content-Type", "application/json")
    .header("Idempotency-Key", "experiment-desk:00328e8c:1358:a1")
    .POST(HttpRequest.BodyPublishers.ofString(inputJson))
    .build();

StringBuilder raw = new StringBuilder();
HTTP.send(stream, HttpResponse.BodyHandlers.ofLines())
    .body()
    .filter(l -> l.startsWith("data:"))
    .forEach(l -> raw.append(l.substring(5)));

uri = URI(BASE + "/run-stream")
req = Net::HTTP::Post.new(uri)
req["Authorization"]   = "Bearer #{TOKEN}"
req["Content-Type"]    = "application/json"
req["Idempotency-Key"] = "experiment-desk:00328e8c:1358:a1"
req.body = JSON.dump(payload)

raw, event = +"", nil
Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(req) do |res|
    res.read_body do |chunk|
      chunk.each_line do |line|
        event = line[6..].strip if line.start_with?("event:")
        raw << JSON.parse(line[5..])["text"] if line.start_with?("data:") && event == "delta"
      end
    end
  end
end

<?php
$raw = "";
$event = null;
$ch = curl_init(BASE . "/run-stream");
curl_setopt_array($ch, [
    CURLOPT_POST       => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer " . TOKEN,
        "Content-Type: application/json",
        "Idempotency-Key: experiment-desk:00328e8c:1358:a1",
    ],
    CURLOPT_POSTFIELDS => json_encode($payload),
    CURLOPT_WRITEFUNCTION => function ($ch, $chunk) use (&$raw, &$event) {
        foreach (explode("\n", $chunk) as $line) {
            if (str_starts_with($line, "event:")) {
                $event = trim(substr($line, 6));
            } elseif (str_starts_with($line, "data:") && $event === "delta") {
                $raw .= json_decode(substr($line, 5), true)["text"] ?? "";
            }
        }
        return strlen($chunk);
    },
]);
curl_exec($ch);

var streamMsg = new HttpRequestMessage(HttpMethod.Post, BASE + "/run-stream")
{
    Content = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json")
};
streamMsg.Headers.Add("Idempotency-Key", "experiment-desk:00328e8c:1358:a1");

var streamRes = await http.SendAsync(streamMsg, HttpCompletionOption.ResponseHeadersRead);
using var reader = new StreamReader(await streamRes.Content.ReadAsStreamAsync());
var raw = new StringBuilder();
string? evt = null, line;
while ((line = await reader.ReadLineAsync()) != null)
{
    if (line.StartsWith("event:")) evt = line[6..].Trim();
    else if (line.StartsWith("data:") && evt == "delta")
        raw.Append(JsonDocument.Parse(line[5..]).RootElement.GetProperty("text").GetString());
}

# create
curl -sS -X POST "$BASE/collections/readouts/records" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"title":"Checkout - single page versus three steps","experiment":"Checkout - single page versus three steps","decision":"ship","p_value":0.0000418,"lift_rel":0.1017,"check_fails":0,"ran_at":"2026-08-08T09:00:00Z","summary":"checkout completion +10.2% at p < 0.0001; refund rate moved the wrong way but within noise; decision Ship it"}'

# exact filter - about a tenth the cost of a similarity query
curl -sS -X POST "$BASE/collections/readouts/query" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"where":{"decision":{"eq":"extend"}},"sort":{"field":"ran_at","dir":"desc"},"limit":20}'

# semantic search - 30 requests/min per IP, so debounce it
curl -sS -X POST "$BASE/collections/readouts/similar" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"text":"the checkout one where refunds moved the wrong way","limit":8}'

rec = call("/collections/readouts/records", {
    "title": "Checkout - single page versus three steps",
    "experiment": "Checkout - single page versus three steps",
    "decision": "ship",
    "p_value": 0.0000418,
    "lift_rel": 0.1017,
    "check_fails": 0,
    "ran_at": "2026-08-08T09:00:00Z",
    "summary": "checkout completion +10.2% at p < 0.0001; decision Ship it",
})

page = call("/collections/readouts/query", {
    "where": {"decision": {"eq": "extend"}},
    "sort": {"field": "ran_at", "dir": "desc"},
    "limit": 20,
})

hits = call("/collections/readouts/similar",
            {"text": "the checkout one where refunds moved the wrong way", "limit": 8})

// the SDK's similar() resolves to the record ARRAY; query() to { records }.
// Accept either shape rather than trusting one.
const recordsOf = (r) => (Array.isArray(r) ? r : (r && r.records) || []);

await call("/collections/readouts/records", {
  title: "Checkout - single page versus three steps",
  experiment: "Checkout - single page versus three steps",
  decision: "ship",
  p_value: 0.0000418,
  lift_rel: 0.1017,
  check_fails: 0,
  ran_at: new Date().toISOString(),
  summary: "checkout completion +10.2% at p < 0.0001; decision Ship it"
});

const page = await call("/collections/readouts/query", {
  where: { decision: { eq: "extend" } },
  sort: { field: "ran_at", dir: "desc" },
  limit: 20
});
console.log(recordsOf(page).length);

rec := map[string]any{
    "title":       "Checkout - single page versus three steps",
    "experiment":  "Checkout - single page versus three steps",
    "decision":    "ship",
    "p_value":     0.0000418,
    "lift_rel":    0.1017,
    "check_fails": 0,
    "ran_at":      time.Now().UTC().Format(time.RFC3339),
}
call("/collections/readouts/records", rec)

call("/collections/readouts/query", map[string]any{
    "where": map[string]any{"decision": map[string]any{"eq": "extend"}},
    "sort":  map[string]any{"field": "ran_at", "dir": "desc"},
    "limit": 20,
})

call("/collections/readouts/records",
     "{\"title\":\"Checkout - single page versus three steps\"," +
     "\"decision\":\"ship\",\"p_value\":0.0000418," +
     "\"ran_at\":\"2026-08-08T09:00:00Z\"}");

call("/collections/readouts/query",
     "{\"where\":{\"decision\":{\"eq\":\"extend\"}}," +
     "\"sort\":{\"field\":\"ran_at\",\"dir\":\"desc\"},\"limit\":20}");

call("/collections/readouts/records", {
  title:       "Checkout - single page versus three steps",
  experiment:  "Checkout - single page versus three steps",
  decision:    "ship",
  p_value:     0.0000418,
  lift_rel:    0.1017,
  check_fails: 0,
  ran_at:      Time.now.utc.iso8601
})

call("/collections/readouts/query", {
  where: { decision: { eq: "extend" } },
  sort:  { field: "ran_at", dir: "desc" },
  limit: 20
})

<?php
call("/collections/readouts/records", [
    "title"       => "Checkout - single page versus three steps",
    "experiment"  => "Checkout - single page versus three steps",
    "decision"    => "ship",
    "p_value"     => 0.0000418,
    "lift_rel"    => 0.1017,
    "check_fails" => 0,
    "ran_at"      => gmdate("c"),
]);

call("/collections/readouts/query", [
    "where" => ["decision" => ["eq" => "extend"]],
    "sort"  => ["field" => "ran_at", "dir" => "desc"],
    "limit" => 20,
]);

await Call("/collections/readouts/records", new {
    title       = "Checkout - single page versus three steps",
    experiment  = "Checkout - single page versus three steps",
    decision    = "ship",
    p_value     = 0.0000418,
    lift_rel    = 0.1017,
    check_fails = 0,
    ran_at      = DateTime.UtcNow.ToString("o")
});

await Call("/collections/readouts/query", new {
    where = new { decision = new { eq = "extend" } },
    sort  = new { field = "ran_at", dir = "desc" },
    limit = 20
});