Driving Rhythm Desk from your own code

API=https://api.skillsafe.ai

TOKEN=$(curl -sS -X POST "$API/v1/app-api/guest" \
  -H 'Content-Type: application/json' \
  -d '{"slug":"rhythm-desk"}' | jq -r '.data.token')

curl -sS "$API/v1/app-api/me" -H "Authorization: Bearer $TOKEN" | jq '.data'
# { "subject_type": "guest", "subject_id": "gst_…", "credits": 0 }

import requests

API = "https://api.skillsafe.ai"

r = requests.post(f"{API}/v1/app-api/guest", json={"slug": "rhythm-desk"})
r.raise_for_status()
token = r.json()["data"]["token"]

me = requests.get(f"{API}/v1/app-api/me",
                  headers={"Authorization": f"Bearer {token}"}).json()["data"]
print(me["subject_type"], me["credits"])

const API = "https://api.skillsafe.ai";

const g = await fetch(`${API}/v1/app-api/guest`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ slug: "rhythm-desk" }),
});
const { data: { token } } = await g.json();

const me = await fetch(`${API}/v1/app-api/me`, {
  headers: { Authorization: `Bearer ${token}` },
}).then((r) => r.json());
console.log(me.data.subject_type, me.data.credits);

package main

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

const API = "https://api.skillsafe.ai"

func main() {
	body, _ := json.Marshal(map[string]string{"slug": "rhythm-desk"})
	res, err := http.Post(API+"/v1/app-api/guest", "application/json", bytes.NewReader(body))
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	var out struct {
		Data struct {
			Token string `json:"token"`
		} `json:"data"`
	}
	json.NewDecoder(res.Body).Decode(&out)

	req, _ := http.NewRequest("GET", API+"/v1/app-api/me", nil)
	req.Header.Set("Authorization", "Bearer "+out.Data.Token)
	me, _ := http.DefaultClient.Do(req)
	defer me.Body.Close()

	var who map[string]any
	json.NewDecoder(me.Body).Decode(&who)
	fmt.Println(who["data"])
}

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

var api = "https://api.skillsafe.ai";
var http = HttpClient.newHttpClient();

var guest = http.send(HttpRequest.newBuilder()
        .uri(URI.create(api + "/v1/app-api/guest"))
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString("{\"slug\":\"rhythm-desk\"}"))
        .build(),
    HttpResponse.BodyHandlers.ofString());

// use your JSON library of choice to pull data.token out of guest.body()
String token = extractToken(guest.body());

var me = http.send(HttpRequest.newBuilder()
        .uri(URI.create(api + "/v1/app-api/me"))
        .header("Authorization", "Bearer " + token)
        .GET().build(),
    HttpResponse.BodyHandlers.ofString());
System.out.println(me.body());

require "net/http"
require "json"

API = URI("https://api.skillsafe.ai")

guest = Net::HTTP.post(URI("#{API}/v1/app-api/guest"),
                       { slug: "rhythm-desk" }.to_json,
                       "Content-Type" => "application/json")
token = JSON.parse(guest.body)["data"]["token"]

req = Net::HTTP::Get.new(URI("#{API}/v1/app-api/me"))
req["Authorization"] = "Bearer #{token}"
me = Net::HTTP.start(API.host, API.port, use_ssl: true) { |h| h.request(req) }
puts JSON.parse(me.body)["data"]

<?php
$api = "https://api.skillsafe.ai";

$guest = json_decode(file_get_contents("$api/v1/app-api/guest", false,
  stream_context_create(["http" => [
    "method"  => "POST",
    "header"  => "Content-Type: application/json",
    "content" => json_encode(["slug" => "rhythm-desk"]),
  ]])), true);
$token = $guest["data"]["token"];

$me = json_decode(file_get_contents("$api/v1/app-api/me", false,
  stream_context_create(["http" => [
    "header" => "Authorization: Bearer $token",
  ]])), true);
echo $me["data"]["subject_type"], " ", $me["data"]["credits"], "\n";

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

const string Api = "https://api.skillsafe.ai";
using var http = new HttpClient();

var guest = await http.PostAsJsonAsync($"{Api}/v1/app-api/guest",
    new { slug = "rhythm-desk" });
var token = (await guest.Content.ReadFromJsonAsync<JsonElement>())
    .GetProperty("data").GetProperty("token").GetString();

http.DefaultRequestHeaders.Authorization = new("Bearer", token);
var me = await http.GetFromJsonAsync<JsonElement>($"{Api}/v1/app-api/me");
Console.WriteLine(me.GetProperty("data"));

API=https://api.skillsafe.ai
TOKEN=…   # personal token from /tokens.html

cat > input.json <<'JSON'
{
  "task": "diagnostics",
  "purpose": "training-recovery",
  "prescan": {
    "ok": true, "signal_type": "ecg", "signal_type_source": "declared-matches-header",
    "sample_rate_hz": 125, "duration_s": 66, "n_samples": 8250,
    "dropped_rows": 0, "truncated_for_size": false, "beat_count": 67,
    "hr":  { "mean": 61.2, "min": 54.7, "max": 68.8 },
    "hrv": { "mean_rr_ms": 980.7, "min_rr_ms": 872, "max_rr_ms": 1096,
             "sdnn_ms": 50.3, "rmssd_ms": 68.6,
             "pnn50_pct": 47.7, "pnn20_pct": 84.6, "cv_pct": 5.13 },
    "respiration": { "present": true, "mean_bpm": 13.9, "breath_count": 16 },
    "flags": []
  }
}
JSON

curl -sS -X POST "$API/v1/app-api/estimate" \
  -H "Authorization: Bearer $TOKEN" -H 'Content-Type: application/json' \
  -d @input.json | jq '.data | {hold_credits, min_credits}'

curl -sS -X POST "$API/v1/app-api/run" \
  -H "Authorization: Bearer $TOKEN" -H 'Content-Type: application/json' \
  -H 'Idempotency-Key: rhythm-desk-ecg-2026-08-29-a1' \
  -d @input.json | jq -r '.data.output.output' | jq '.verdict, .title'

import json, requests

API, TOKEN = "https://api.skillsafe.ai", "…"
H = {"Authorization": f"Bearer {TOKEN}", "Content-Type": "application/json"}

payload = {
    "task": "diagnostics",
    "purpose": "training-recovery",
    "prescan": prescan,   # the facts table you computed
}

est = requests.post(f"{API}/v1/app-api/estimate", headers=H, json=payload).json()["data"]
print(est["hold_credits"], est["min_credits"])

r = requests.post(f"{API}/v1/app-api/run", json=payload,
                  headers={**H, "Idempotency-Key": "rhythm-desk-ecg-a1"})
r.raise_for_status()
data = r.json()["data"]

# output.output is a JSON *string* - parse it a second time
result = json.loads(data["output"]["output"])
print(result["verdict"], "-", result["title"])
for f in result["findings"]:
    print(f'  {f["id"]} [{f["severity"]}] {f["title"]}')

const API = "https://api.skillsafe.ai";
const TOKEN = "…";
const H = { Authorization: `Bearer ${TOKEN}`, "Content-Type": "application/json" };

const payload = {
  task: "diagnostics",
  purpose: "training-recovery",
  prescan,                 // the facts table you computed
};

const est = await fetch(`${API}/v1/app-api/estimate`, {
  method: "POST", headers: H, body: JSON.stringify(payload),
}).then((r) => r.json());
console.log(est.data.hold_credits, est.data.min_credits);

const run = await fetch(`${API}/v1/app-api/run`, {
  method: "POST",
  headers: { ...H, "Idempotency-Key": "rhythm-desk-ecg-a1" },
  body: JSON.stringify(payload),
}).then((r) => r.json());

// output.output is a JSON *string* - parse it a second time
const result = JSON.parse(run.data.output.output);
console.log(result.verdict, "-", result.title);

payload, _ := json.Marshal(map[string]any{
	"task":    "diagnostics",
	"purpose": "training-recovery",
	"prescan": prescan, // the facts table you computed
})

req, _ := http.NewRequest("POST", API+"/v1/app-api/run", bytes.NewReader(payload))
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Idempotency-Key", "rhythm-desk-ecg-a1")

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

var env struct {
	Data struct {
		Output struct {
			Output string `json:"output"`
		} `json:"output"`
	} `json:"data"`
}
json.NewDecoder(res.Body).Decode(&env)

// the inner Output is a JSON string - decode it a second time
var result map[string]any
json.Unmarshal([]byte(env.Data.Output.Output), &result)
fmt.Println(result["verdict"], result["title"])

var payload = """
    {"task":"diagnostics","purpose":"training-recovery","prescan":%s}
    """.formatted(prescanJson);

var run = http.send(HttpRequest.newBuilder()
        .uri(URI.create(api + "/v1/app-api/run"))
        .header("Authorization", "Bearer " + token)
        .header("Content-Type", "application/json")
        .header("Idempotency-Key", "rhythm-desk-ecg-a1")
        .POST(HttpRequest.BodyPublishers.ofString(payload))
        .build(),
    HttpResponse.BodyHandlers.ofString());

// data.output.output is a JSON string - parse it, then parse that
String inner = readPath(run.body(), "data", "output", "output");
var result = parseJson(inner);
System.out.println(result.get("verdict") + " - " + result.get("title"));

payload = {
  task: "diagnostics",
  purpose: "training-recovery",
  prescan: prescan          # the facts table you computed
}.to_json

req = Net::HTTP::Post.new(URI("#{API}/v1/app-api/run"))
req["Authorization"]   = "Bearer #{token}"
req["Content-Type"]    = "application/json"
req["Idempotency-Key"] = "rhythm-desk-ecg-a1"
req.body = payload

res = Net::HTTP.start(API.host, API.port, use_ssl: true) { |h| h.request(req) }

# output.output is a JSON string - parse it a second time
result = JSON.parse(JSON.parse(res.body)["data"]["output"]["output"])
puts "#{result["verdict"]} - #{result["title"]}"

<?php
$payload = json_encode([
  "task"    => "diagnostics",
  "purpose" => "training-recovery",
  "prescan" => $prescan,   // the facts table you computed
]);

$res = file_get_contents("$api/v1/app-api/run", false,
  stream_context_create(["http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer $token\r\n"
               . "Content-Type: application/json\r\n"
               . "Idempotency-Key: rhythm-desk-ecg-a1\r\n",
    "content" => $payload,
  ]]));

// output.output is a JSON string - decode it a second time
$env    = json_decode($res, true);
$result = json_decode($env["data"]["output"]["output"], true);
echo $result["verdict"], " - ", $result["title"], "\n";

var payload = new
{
    task = "diagnostics",
    purpose = "training-recovery",
    prescan,                 // the facts table you computed
};

var req = new HttpRequestMessage(HttpMethod.Post, $"{Api}/v1/app-api/run")
{
    Content = JsonContent.Create(payload),
};
req.Headers.Add("Idempotency-Key", "rhythm-desk-ecg-a1");

var res = await http.SendAsync(req);
var env = await res.Content.ReadFromJsonAsync<JsonElement>();

// output.output is a JSON string - parse it a second time
var inner = env.GetProperty("data").GetProperty("output")
               .GetProperty("output").GetString();
var result = JsonDocument.Parse(inner!).RootElement;
Console.WriteLine($"{result.GetProperty("verdict")} - {result.GetProperty("title")}");