Example apps & starters

# A complete, runnable integration — paste the whole block into a terminal.
# No API key: this targets the open partner sandbox.
HOST="https://phosra-api-sandbox-production.up.railway.app"
BASE="$HOST/api/v1"

# 1 — health check (no key)
curl -s "$HOST/health"           # → {"status":"ok"}

# 2 — create a protected child; capture the child id
CHILD_ID=$(curl -s -X POST "$BASE/setup/quick" \
  -H "Content-Type: application/json" \
  -d '{"child_name":"Aria","birth_date":"2015-08-20","strictness":"recommended"}' \
  | jq -r '.child.id')
echo "child: $CHILD_ID"

# 3 — enforce → returns a job (status "running")
JOB_ID=$(curl -s -X POST "$BASE/children/$CHILD_ID/enforce" | jq -r '.id')
echo "job:   $JOB_ID"

# 4 — poll the job until it is "completed"
curl -s "$BASE/enforcement/jobs/$JOB_ID" | jq '{status, completed_at}'

// Full program. `npx tsx starter.ts` — Node 18+ (global fetch), zero dependencies.
const BASE = "https://phosra-api-sandbox-production.up.railway.app/api/v1";

async function main() {
  // 1 — health (no key)
  const health = await fetch(`${BASE.replace("/api/v1", "")}/health`).then((r) => r.json());
  console.log("health:", health.status); // ok

  // 2 — create family + child + active policy in one call
  const setup = await fetch(`${BASE}/setup/quick`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      child_name: "Aria",
      birth_date: "2015-08-20",
      strictness: "recommended",
    }),
  }).then((r) => r.json());
  const childId: string = setup.child.id;
  console.log("child:", childId, "| policy:", setup.policy.status, "| rules:", setup.rules.length);

  // 3 — enforce → async job
  const job = await fetch(`${BASE}/children/${childId}/enforce`, { method: "POST" }).then((r) =>
    r.json(),
  );
  console.log("job:", job.id, job.status);

  // 4 — poll until completed
  let result = job;
  while (result.status !== "completed" && result.status !== "failed") {
    await new Promise((r) => setTimeout(r, 500));
    result = await fetch(`${BASE}/enforcement/jobs/${job.id}`).then((r) => r.json());
  }
  console.log("final:", result.status, result.completed_at);
}

main();

# Full program. `python starter.py` — needs `requests` (pip install requests).
import time
import requests

BASE = "https://phosra-api-sandbox-production.up.railway.app/api/v1"

# 1 — health (no key)
print("health:", requests.get(f"{BASE.rsplit('/api/v1', 1)[0]}/health", timeout=30).json()["status"])

# 2 — create family + child + active policy in one call
setup = requests.post(
    f"{BASE}/setup/quick",
    json={"child_name": "Aria", "birth_date": "2015-08-20", "strictness": "recommended"},
    timeout=30,
).json()
child_id = setup["child"]["id"]
print("child:", child_id, "| policy:", setup["policy"]["status"], "| rules:", len(setup["rules"]))

# 3 — enforce → async job
job = requests.post(f"{BASE}/children/{child_id}/enforce", timeout=30).json()
print("job:", job["id"], job["status"])

# 4 — poll until completed
while job["status"] not in ("completed", "failed"):
    time.sleep(0.5)
    job = requests.get(f"{BASE}/enforcement/jobs/{job['id']}", timeout=30).json()
print("final:", job["status"], job["completed_at"])

// Full program. Save as main.go in an empty dir, then `go mod init starter && go run .`
package main

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

const base = "https://phosra-api-sandbox-production.up.railway.app/api/v1"

type job struct {
	ID          string `json:"id"`
	Status      string `json:"status"`
	CompletedAt string `json:"completed_at"`
}

func main() {
	// 2 — create family + child + active policy in one call
	body, _ := json.Marshal(map[string]string{
		"child_name": "Aria", "birth_date": "2015-08-20", "strictness": "recommended",
	})
	res, _ := http.Post(base+"/setup/quick", "application/json", bytes.NewReader(body))
	var setup struct {
		Child struct {
			ID string `json:"id"`
		} `json:"child"`
		Policy struct {
			Status string `json:"status"`
		} `json:"policy"`
		Rules []json.RawMessage `json:"rules"`
	}
	json.NewDecoder(res.Body).Decode(&setup)
	res.Body.Close()
	fmt.Println("child:", setup.Child.ID, "| policy:", setup.Policy.Status, "| rules:", len(setup.Rules))

	// 3 — enforce → async job
	res, _ = http.Post(base+"/children/"+setup.Child.ID+"/enforce", "application/json", nil)
	var j job
	json.NewDecoder(res.Body).Decode(&j)
	res.Body.Close()
	fmt.Println("job:", j.ID, j.Status)

	// 4 — poll until completed
	for j.Status != "completed" && j.Status != "failed" {
		time.Sleep(500 * time.Millisecond)
		res, _ = http.Get(base + "/enforcement/jobs/" + j.ID)
		json.NewDecoder(res.Body).Decode(&j)
		res.Body.Close()
	}
	fmt.Println("final:", j.Status, j.CompletedAt)
}