Driving House Style from your own code

# A token first (see step 1). Everything below reuses it.
TOKEN="YOUR_TOKEN"
BASE="https://api.skillsafe.ai/v1/app-api"

import json, urllib.request

BASE = "https://api.skillsafe.ai/v1/app-api"
TOKEN = "YOUR_TOKEN"   # from tokens.html, or POST /guest below

def call(method, path, body=None):
    data = None if body is None else json.dumps(body).encode()
    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:
        return json.load(r)["data"]

const BASE = "https://api.skillsafe.ai/v1/app-api";
const TOKEN = "YOUR_TOKEN";   // from tokens.html, or POST /guest below

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

package main

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

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

func call(method, path string, body any) (map[string]any, error) {
    var rdr io.Reader
    if body != nil {
        b, _ := json.Marshal(body)
        rdr = bytes.NewReader(b)
    }
    req, _ := http.NewRequest(method, base+path, rdr)
    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 struct {
        Data map[string]any `json:"data"`
    }
    err = json.NewDecoder(res.Body).Decode(&env)
    return env.Data, err
}

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

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

static String call(String method, String path, String jsonBody) throws Exception {
    HttpRequest.BodyPublisher body = jsonBody == null
        ? HttpRequest.BodyPublishers.noBody()
        : HttpRequest.BodyPublishers.ofString(jsonBody);
    HttpRequest req = HttpRequest.newBuilder(URI.create(BASE + path))
        .header("Authorization", "Bearer " + TOKEN)
        .header("Content-Type", "application/json")
        .method(method, body)
        .build();
    return HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString()).body();
}

require "json"
require "net/http"

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

def call(method, path, body = nil)
  uri = URI(BASE.to_s + 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) }
  JSON.parse(res.body)["data"]
end

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

function call(string $method, string $path, ?array $body = null) {
    $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));
    }
    $out = json_decode(curl_exec($ch), true);
    curl_close($ch);
    return $out["data"] ?? null;
}

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

const string Base  = "https://api.skillsafe.ai/v1/app-api";
const string Token = "YOUR_TOKEN";

var http = new HttpClient();
http.DefaultRequestHeaders.Add("Authorization", "Bearer " + Token);

async Task<JsonElement> Call(HttpMethod method, string path, object? body = null) {
    var req = new HttpRequestMessage(method, Base + path);
    if (body is not null) req.Content = JsonContent.Create(body);
    var res  = await http.SendAsync(req);
    var json = await res.Content.ReadFromJsonAsync<JsonElement>();
    return json.GetProperty("data");
}

curl -s -X POST "$BASE/guest" \
  -H "Content-Type: application/json" \
  -d '{"slug":"house-style"}'
# -> {"data":{"token":"aut_...","guest_id":"gst_..."}}

req = urllib.request.Request(BASE + "/guest",
    data=json.dumps({"slug": "house-style"}).encode(), method="POST")
req.add_header("Content-Type", "application/json")
with urllib.request.urlopen(req) as r:
    TOKEN = json.load(r)["data"]["token"]

const res  = await fetch(BASE + "/guest", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ slug: "house-style" })
});
const TOKEN = (await res.json()).data.token;

b, _ := json.Marshal(map[string]string{"slug": "house-style"})
res, _ := http.Post(base+"/guest", "application/json", bytes.NewReader(b))
// read res.Body -> {"data":{"token":"aut_..."}}

String body = "{\"slug\":\"house-style\"}";
// POST BASE + "/guest" with Content-Type: application/json and no Authorization
// header; read data.token out of the reply.

uri = URI(BASE.to_s + "/guest")
res = Net::HTTP.post(uri, JSON.dump({ slug: "house-style" }),
                     "Content-Type" => "application/json")
TOKEN = JSON.parse(res.body)["data"]["token"]

$ch = curl_init(BASE . "/guest");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => ["Content-Type: application/json"],
    CURLOPT_POSTFIELDS     => json_encode(["slug" => "house-style"]),
]);
$token = json_decode(curl_exec($ch), true)["data"]["token"];

var guest = await http.PostAsJsonAsync(Base + "/guest", new { slug = "house-style" });
var token = (await guest.Content.ReadFromJsonAsync<JsonElement>())
    .GetProperty("data").GetProperty("token").GetString();

curl -s "$BASE/me" -H "Authorization: Bearer $TOKEN"

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

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

me, err := call("GET", "/me", nil)
if err != nil {
    panic(err)
}
fmt.Println(me["subject_type"], me["credits"])

String me = call("GET", "/me", null);
System.out.println(me);

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

$me = call("GET", "/me");
echo $me["subject_type"], " ", $me["credits"];

var me = await Call(HttpMethod.Get, "/me");
Console.WriteLine(me.GetProperty("credits"));

curl -s -X POST "$BASE/estimate" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"task":"enforce","samples":"## Introducing Tidewell Forecasting...","guide":"{}","audience":"customers","channel":"web","register":"auto","notes":"","prescan":{"words":120,"flags":[]}}'
# -> {"data":{"model":"gpt-5.6-terra","model_alias":"gpt-terra","markup_bps":1000,
#             "hold_credits":4210,"min_credits":420,"sponsor_enabled":false}}

payload = {
    "task": "enforce",
    "samples": "## Introducing Tidewell Forecasting...",
    "guide": "{\"kind\":\"style_rules\",\"rules\":[...]}",
    "audience": "existing customers on the Growth plan",
    "channel": "web",
    "register": "auto",
    "notes": "",
    "prescan": {"words": 120, "flags": [{"id": "buzzwords", "severity": "high"}]}
}

est = call("POST", "/estimate", payload)
print(est["model"], est["model_alias"], est["hold_credits"], est["min_credits"])

const payload = {
  task: "enforce",
  samples: "## Introducing Tidewell Forecasting...",
  guide: JSON.stringify(styleRules),
  audience: "existing customers on the Growth plan",
  channel: "web",
  register: "auto",
  notes: "",
  prescan: { words: 120, flags: [{ id: "buzzwords", severity: "high" }] }
};

const est = await call("POST", "/estimate", payload);
console.log(est.model, est.hold_credits, est.min_credits);

payload := map[string]any{
    "task":     "enforce",
    "samples":  "## Introducing Tidewell Forecasting...",
    "guide":    styleRulesJSON,
    "audience": "existing customers on the Growth plan",
    "channel":  "web",
    "register": "auto",
    "prescan":  map[string]any{"words": 120},
}
est, _ := call("POST", "/estimate", payload)
fmt.Println(est["model"], est["hold_credits"])

String payload = """
    {"task":"enforce","samples":"## Introducing Tidewell Forecasting...",
     "guide":"{}","audience":"customers","channel":"web","register":"auto",
     "notes":"","prescan":{"words":120,"flags":[]}}
    """;
System.out.println(call("POST", "/estimate", payload));

payload = {
  task: "enforce",
  samples: "## Introducing Tidewell Forecasting...",
  guide: style_rules.to_json,
  audience: "existing customers on the Growth plan",
  channel: "web",
  register: "auto",
  notes: "",
  prescan: { words: 120, flags: [] }
}
est = call("POST", "/estimate", payload)
puts est["model"], est["hold_credits"]

$payload = [
    "task"     => "enforce",
    "samples"  => "## Introducing Tidewell Forecasting...",
    "guide"    => json_encode($styleRules),
    "audience" => "existing customers on the Growth plan",
    "channel"  => "web",
    "register" => "auto",
    "notes"    => "",
    "prescan"  => ["words" => 120, "flags" => []],
];
$est = call("POST", "/estimate", $payload);
echo $est["model"], " ", $est["hold_credits"];

var payload = new {
    task     = "enforce",
    samples  = "## Introducing Tidewell Forecasting...",
    guide    = styleRulesJson,
    audience = "existing customers on the Growth plan",
    channel  = "web",
    register = "auto",
    notes    = "",
    prescan  = new { words = 120 }
};
var est = await Call(HttpMethod.Post, "/estimate", payload);
Console.WriteLine(est.GetProperty("hold_credits"));

KEY="house-style:enforce:$(printf '%%s' "$SAMPLES$GUIDE" | shasum | cut -c1-16):1"

JOB=$(curl -s -X POST "$BASE/run" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $KEY" \
  -d @payload.json | python3 -c 'import sys,json;print(json.load(sys.stdin)["data"]["job_id"])')

until [ "$(curl -s "$BASE/jobs/$JOB" -H "Authorization: Bearer $TOKEN" \
        | python3 -c 'import sys,json;print(json.load(sys.stdin)["data"]["status"])')" \
      != "running" ]; do sleep 1; done

curl -s "$BASE/jobs/$JOB" -H "Authorization: Bearer $TOKEN"

import time, hashlib

seed = payload["task"] + payload["samples"] + payload["guide"]
key  = "house-style:%s:%s:1" % (payload["task"], hashlib.sha256(seed.encode()).hexdigest()[:16])

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", key)          # a retry must reuse it
with urllib.request.urlopen(req) as r:
    job_id = json.load(r)["data"]["job_id"]

while True:
    job = call("GET", "/jobs/" + job_id)
    if job["status"] != "running":
        break
    time.sleep(1)

result = json.loads(job["output"])
print(result["verdict"], len(result["findings"]))

const key = `house-style:${payload.task}:${hash(payload)}:1`;   // reuse on retry

const started = await fetch(BASE + "/run", {
  method: "POST",
  headers: {
    "Authorization": "Bearer " + TOKEN,
    "Content-Type": "application/json",
    "Idempotency-Key": key
  },
  body: JSON.stringify(payload)
});
const { data } = await started.json();

let job;
do {
  await new Promise(r => setTimeout(r, 1000));
  job = await call("GET", "/jobs/" + data.job_id);
} while (job.status === "running");

const result = JSON.parse(job.output);
console.log(result.verdict, result.findings.length);

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", key)   // same key on every retry
res, _ := http.DefaultClient.Do(req)
// read data.job_id, then GET /jobs/{id} until status != "running"

HttpRequest req = HttpRequest.newBuilder(URI.create(BASE + "/run"))
    .header("Authorization", "Bearer " + TOKEN)
    .header("Content-Type", "application/json")
    .header("Idempotency-Key", key)
    .POST(HttpRequest.BodyPublishers.ofString(payload))
    .build();
// read data.job_id, then poll GET /jobs/{id} until status != "running"

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

loop do
  job = call("GET", "/jobs/#{job_id}")
  break job if job["status"] != "running"
  sleep 1
end

$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: " . $key,
    ],
    CURLOPT_POSTFIELDS     => json_encode($payload),
]);
$jobId = json_decode(curl_exec($ch), true)["data"]["job_id"];

do {
    sleep(1);
    $job = call("GET", "/jobs/" . $jobId);
} while ($job["status"] === "running");

var req = new HttpRequestMessage(HttpMethod.Post, Base + "/run") {
    Content = JsonContent.Create(payload)
};
req.Headers.Add("Idempotency-Key", key);
var started = await http.SendAsync(req);
var jobId = (await started.Content.ReadFromJsonAsync<JsonElement>())
    .GetProperty("data").GetProperty("job_id").GetString();

JsonElement job;
do {
    await Task.Delay(1000);
    job = await Call(HttpMethod.Get, "/jobs/" + jobId);
} while (job.GetProperty("status").GetString() == "running");

curl -N -X POST "$BASE/run-stream" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $KEY" \
  -d @payload.json

# event: delta   data: {"text":"{\"lane\":\"enfor"}
# event: delta   data: {"text":"ce\",\"title\":\"For"}
# event: done    data: {"job_id":"job_...","charged_credits":1980,"output":"{...}"}

req = urllib.request.Request(BASE + "/run-stream",
    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", key)

buf = ""
with urllib.request.urlopen(req) as r:
    for line in r:
        line = line.decode().strip()
        if line.startswith("data: "):
            evt = json.loads(line[6:])
            if "text" in evt:
                buf += evt["text"]
            elif "output" in evt:
                buf = evt["output"]

result = json.loads(buf)

const res = await fetch(BASE + "/run-stream", {
  method: "POST",
  headers: {
    "Authorization": "Bearer " + TOKEN,
    "Content-Type": "application/json",
    "Idempotency-Key": key
  },
  body: JSON.stringify(payload)
});

const reader = res.body.getReader();
const dec = new TextDecoder();
let buf = "", out = "";
for (;;) {
  const { value, done } = await reader.read();
  if (done) break;
  buf += dec.decode(value, { stream: true });
  for (const line of buf.split("\n")) {
    if (!line.startsWith("data: ")) continue;
    const evt = JSON.parse(line.slice(6));
    if (evt.text) out += evt.text;
    if (evt.output) out = evt.output;
  }
  buf = buf.slice(buf.lastIndexOf("\n") + 1);
}
const result = JSON.parse(out);

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", key)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()

sc := bufio.NewScanner(res.Body)
for sc.Scan() {
    line := sc.Text()
    if strings.HasPrefix(line, "data: ") {
        // {"text": "..."} while generating, {"output": "..."} at the end
    }
}

HttpRequest req = HttpRequest.newBuilder(URI.create(BASE + "/run-stream"))
    .header("Authorization", "Bearer " + TOKEN)
    .header("Content-Type", "application/json")
    .header("Idempotency-Key", key)
    .POST(HttpRequest.BodyPublishers.ofString(payload))
    .build();

HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofLines())
    .body()
    .filter(l -> l.startsWith("data: "))
    .forEach(l -> System.out.println(l.substring(6)));

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

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|
        next unless line.start_with?("data: ")
        evt = JSON.parse(line[6..])
        # evt["text"] while generating, evt["output"] at the end
      end
    end
  end
end

$ch = curl_init(BASE . "/run-stream");
curl_setopt_array($ch, [
    CURLOPT_POST       => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer " . TOKEN,
        "Content-Type: application/json",
        "Idempotency-Key: " . $key,
    ],
    CURLOPT_POSTFIELDS => json_encode($payload),
    CURLOPT_WRITEFUNCTION => function ($ch, $chunk) {
        foreach (explode("\n", $chunk) as $line) {
            if (str_starts_with($line, "data: ")) {
                $evt = json_decode(substr($line, 6), true);
                // $evt["text"] while generating, $evt["output"] at the end
            }
        }
        return strlen($chunk);
    },
]);
curl_exec($ch);

var req = new HttpRequestMessage(HttpMethod.Post, Base + "/run-stream") {
    Content = JsonContent.Create(payload)
};
req.Headers.Add("Idempotency-Key", key);

var res    = await http.SendAsync(req, HttpCompletionOption.ResponseHeadersRead);
using var reader = new StreamReader(await res.Content.ReadAsStreamAsync());
while (await reader.ReadLineAsync() is string line) {
    if (line.StartsWith("data: ")) {
        // {"text": "..."} while generating, {"output": "..."} at the end
    }
}