SDK & API

import { mount } from "@stelehq/sdk";

const widget = mount(document.querySelector("#terms"), {
  apiBaseUrl: "https://stele.site/api",
  appUrl: "https://stele.site",
  organization: "acme.com",
  document: "terms-of-service",
  onAccepted: (result) => console.log(result.acceptanceId),
});

"use client"; // Next.js App Router only

import { TermsAcceptance } from "@stelehq/sdk/react";

export function Terms({ sessionToken }: { sessionToken?: string }) {
  return (
    <TermsAcceptance
      apiBaseUrl="https://stele.site/api"
      appUrl="https://stele.site"
      organization="acme.com"
      document="terms-of-service"
      sessionToken={sessionToken}
      onAccepted={(result) => console.log(result.acceptanceId)}
    />
  );
}

# Every cURL sample reads your key from this variable
export STELE_API_KEY="stl_test_…"

// npm install @stelehq/sdk
import { SteleServerClient } from "@stelehq/sdk/server";

export const stele = new SteleServerClient({
  apiBaseUrl: "https://stele.site/api",
  apiKey: process.env.STELE_API_KEY!,
});

# pip install requests
import os

import requests

BASE_URL = "https://stele.site/api/v1"
http = requests.Session()
http.headers["Authorization"] = f"Bearer {os.environ['STELE_API_KEY']}"


def stele(method, path, **kwargs):
    """Calls the Stele API and returns the JSON body; raises on an error status."""
    response = http.request(method, BASE_URL + path, timeout=10, **kwargs)
    if not response.ok:
        raise RuntimeError(f"Stele {response.status_code}: {response.text}")
    return response.json()

// Stele.java: Java 17+ and Jackson (com.fasterxml.jackson.core:jackson-databind).
// Samples also import com.fasterxml.jackson.databind.JsonNode and java.util.Map.
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.Map;
import java.util.stream.Collectors;

public final class Stele {
  public static final String BASE_URL = "https://stele.site/api/v1";
  private static final String API_KEY = System.getenv("STELE_API_KEY");
  // HTTP/1.1: no h2c upgrade attempt, which plain-HTTP test servers and proxies may reject.
  private static final HttpClient HTTP =
      HttpClient.newBuilder().version(HttpClient.Version.HTTP_1_1).build();
  private static final ObjectMapper JSON = new ObjectMapper();

  public static JsonNode get(String path) throws IOException, InterruptedException {
    return send(HttpRequest.newBuilder(URI.create(BASE_URL + path)).GET());
  }

  public static JsonNode get(String path, Map<String, ?> query)
      throws IOException, InterruptedException {
    return get(path + "?" + query.entrySet().stream()
        .map(e -> e.getKey() + "="
            + URLEncoder.encode(String.valueOf(e.getValue()), StandardCharsets.UTF_8))
        .collect(Collectors.joining("&")));
  }

  public static JsonNode post(String path, Object body) throws IOException, InterruptedException {
    return send(HttpRequest.newBuilder(URI.create(BASE_URL + path))
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(JSON.writeValueAsString(body))));
  }

  private static JsonNode send(HttpRequest.Builder request)
      throws IOException, InterruptedException {
    HttpResponse<String> response = HTTP.send(
        request.header("Authorization", "Bearer " + API_KEY)
            .timeout(Duration.ofSeconds(10))
            .build(),
        HttpResponse.BodyHandlers.ofString());
    if (response.statusCode() >= 300) {
      throw new IOException("Stele " + response.statusCode() + ": " + response.body());
    }
    return JSON.readTree(response.body());
  }
}

// stele.go: standard library only. Samples run inside a function that returns an error.
package main

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

const baseURL = "https://stele.site/api/v1"

var httpClient = &http.Client{Timeout: 10 * time.Second}

// stele calls the Stele API and decodes the JSON response into out.
func stele(method, path string, body, out any) error {
	var payload io.Reader
	if body != nil {
		encoded, err := json.Marshal(body)
		if err != nil {
			return err
		}
		payload = bytes.NewReader(encoded)
	}
	req, err := http.NewRequest(method, baseURL+path, payload)
	if err != nil {
		return err
	}
	req.Header.Set("Authorization", "Bearer "+os.Getenv("STELE_API_KEY"))
	if body != nil {
		req.Header.Set("Content-Type", "application/json")
	}
	res, err := httpClient.Do(req)
	if err != nil {
		return err
	}
	defer res.Body.Close()
	if res.StatusCode >= 300 {
		msg, _ := io.ReadAll(res.Body)
		return fmt.Errorf("stele %d: %s", res.StatusCode, msg)
	}
	return json.NewDecoder(res.Body).Decode(out)
}

<?php
// stele.php: PHP 8.1+ with the curl extension
const BASE_URL = 'https://stele.site/api/v1';

function stele(string $method, string $path, ?array $body = null): array
{
    $curl = curl_init(BASE_URL . $path);
    $headers = ['Authorization: Bearer ' . getenv('STELE_API_KEY')];
    if ($body !== null) {
        $headers[] = 'Content-Type: application/json';
        curl_setopt($curl, CURLOPT_POSTFIELDS, json_encode($body, JSON_THROW_ON_ERROR));
    }
    curl_setopt_array($curl, [
        CURLOPT_CUSTOMREQUEST => $method,
        CURLOPT_HTTPHEADER => $headers,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 10,
    ]);
    $response = curl_exec($curl);
    $status = curl_getinfo($curl, CURLINFO_RESPONSE_CODE);
    if ($response === false || $status >= 300) {
        throw new RuntimeException("Stele $status: " . ($response ?: curl_error($curl)));
    }
    return json_decode($response, true, 512, JSON_THROW_ON_ERROR);
}

# stele.rb: standard library only
require "json"
require "net/http"

BASE_URL = "https://stele.site/api/v1"

def stele(method, path, body = nil)
  uri = URI(BASE_URL + path)
  request = Net::HTTPGenericRequest.new(method, !body.nil?, true, uri)
  request["Authorization"] = "Bearer #{ENV.fetch("STELE_API_KEY")}"
  if body
    request["Content-Type"] = "application/json"
    request.body = JSON.generate(body)
  end
  response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
                                                 open_timeout: 10, read_timeout: 10) do |http|
    http.request(request)
  end
  raise "Stele #{response.code}: #{response.body}" unless response.is_a?(Net::HTTPSuccess)

  JSON.parse(response.body)
end

// Program.cs: .NET 8 or later, no packages
using System.Net.Http.Json;
using System.Text.Json;

const string BaseUrl = "https://stele.site/api/v1";
var http = new HttpClient { Timeout = TimeSpan.FromSeconds(10) };
http.DefaultRequestHeaders.Authorization =
    new("Bearer", Environment.GetEnvironmentVariable("STELE_API_KEY"));

async Task<JsonElement> Stele(HttpMethod method, string path, object? body = null)
{
    using var request = new HttpRequestMessage(method, BaseUrl + path)
    {
        Content = body is null ? null : JsonContent.Create(body),
    };
    using var response = await http.SendAsync(request);
    var text = await response.Content.ReadAsStringAsync();
    if (!response.IsSuccessStatusCode)
        throw new HttpRequestException($"Stele {(int)response.StatusCode}: {text}");
    return JsonSerializer.Deserialize<JsonElement>(text);
}

curl https://stele.site/api/v1/documents/by-slug/terms-of-service/latest \
  -H "Authorization: Bearer $STELE_API_KEY"

const latest = await stele.latestVersion("terms-of-service");
console.log(latest.version.number, latest.version.address);

latest = stele("GET", "/documents/by-slug/terms-of-service/latest")
print(latest["version"]["number"], latest["version"]["address"])

JsonNode latest = Stele.get("/documents/by-slug/terms-of-service/latest");
System.out.println(latest.at("/version/number") + " " + latest.at("/version/address").asText());

var latest struct {
	Version struct {
		Address string `json:"address"`
		Number  int    `json:"number"`
	} `json:"version"`
}
if err := stele("GET", "/documents/by-slug/terms-of-service/latest", nil, &latest); err != nil {
	return err
}
fmt.Println(latest.Version.Number, latest.Version.Address)

$latest = stele('GET', '/documents/by-slug/terms-of-service/latest');
echo $latest['version']['number'], ' ', $latest['version']['address'], PHP_EOL;

latest = stele("GET", "/documents/by-slug/terms-of-service/latest")
puts "#{latest["version"]["number"]} #{latest["version"]["address"]}"

var latest = await Stele(HttpMethod.Get, "/documents/by-slug/terms-of-service/latest");
var version = latest.GetProperty("version");
Console.WriteLine($"{version.GetProperty("number")} {version.GetProperty("address")}");

curl https://stele.site/api/v1/acceptance-sessions \
  -H "Authorization: Bearer $STELE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "document": "terms-of-service", "externalUserRef": "user_12345" }'

const { sessionToken } = await stele.createAcceptanceSession({
  document: "terms-of-service",
  externalUserRef: "user_12345",
});

session = stele("POST", "/acceptance-sessions", json={
    "document": "terms-of-service",
    "externalUserRef": "user_12345",
})
session_token = session["sessionToken"]

JsonNode session = Stele.post("/acceptance-sessions", Map.of(
    "document", "terms-of-service",
    "externalUserRef", "user_12345"));
String sessionToken = session.get("sessionToken").asText();

var session struct {
	SessionToken string `json:"sessionToken"`
}
err := stele("POST", "/acceptance-sessions", map[string]any{
	"document":        "terms-of-service",
	"externalUserRef": "user_12345",
}, &session)
if err != nil {
	return err
}
fmt.Println(session.SessionToken)

$session = stele('POST', '/acceptance-sessions', [
    'document' => 'terms-of-service',
    'externalUserRef' => 'user_12345',
]);
$sessionToken = $session['sessionToken'];

session = stele("POST", "/acceptance-sessions", {
  document: "terms-of-service",
  externalUserRef: "user_12345",
})
session_token = session["sessionToken"]

var session = await Stele(HttpMethod.Post, "/acceptance-sessions",
    new { document = "terms-of-service", externalUserRef = "user_12345" });
var sessionToken = session.GetProperty("sessionToken").GetString();

curl "https://stele.site/api/v1/acceptances?externalUserRef=user_12345&limit=50" \
  -H "Authorization: Bearer $STELE_API_KEY"

# Next page: add the nextCursor value from the previous response
curl "https://stele.site/api/v1/acceptances?externalUserRef=user_12345&limit=50&cursor=$CURSOR" \
  -H "Authorization: Bearer $STELE_API_KEY"

let cursor: string | undefined;
do {
  const page = await stele.listAcceptances({ externalUserRef: "user_12345", limit: 50, cursor });
  for (const acceptance of page.acceptances) {
    console.log(acceptance.acceptanceId, acceptance.versionNumber);
  }
  cursor = page.nextCursor ?? undefined;
} while (cursor);

cursor = None
while True:
    page = stele("GET", "/acceptances", params={
        "externalUserRef": "user_12345",
        "limit": 50,
        "cursor": cursor,  # None is left out
    })
    for acceptance in page["acceptances"]:
        print(acceptance["acceptanceId"], acceptance["versionNumber"])
    cursor = page["nextCursor"]
    if cursor is None:
        break

String cursor = null;
do {
  Map<String, Object> query = new java.util.HashMap<>(
      Map.of("externalUserRef", "user_12345", "limit", 50));
  if (cursor != null) query.put("cursor", cursor);
  JsonNode page = Stele.get("/acceptances", query);
  for (JsonNode acceptance : page.get("acceptances")) {
    System.out.println(acceptance.get("acceptanceId").asText());
  }
  cursor = page.get("nextCursor").isNull() ? null : page.get("nextCursor").asText();
} while (cursor != null);

cursor := ""
for {
	query := url.Values{"externalUserRef": {"user_12345"}, "limit": {"50"}}
	if cursor != "" {
		query.Set("cursor", cursor)
	}
	var page struct {
		Acceptances []struct {
			AcceptanceID  string `json:"acceptanceId"`
			VersionNumber int    `json:"versionNumber"`
		} `json:"acceptances"`
		NextCursor *string `json:"nextCursor"`
	}
	if err := stele("GET", "/acceptances?"+query.Encode(), nil, &page); err != nil {
		return err
	}
	for _, acceptance := range page.Acceptances {
		fmt.Println(acceptance.AcceptanceID, acceptance.VersionNumber)
	}
	if page.NextCursor == nil {
		break
	}
	cursor = *page.NextCursor
}

$cursor = null;
do {
    $page = stele('GET', '/acceptances?' . http_build_query([
        'externalUserRef' => 'user_12345',
        'limit' => 50,
        'cursor' => $cursor, // null is left out
    ]));
    foreach ($page['acceptances'] as $acceptance) {
        echo $acceptance['acceptanceId'], ' ', $acceptance['versionNumber'], PHP_EOL;
    }
    $cursor = $page['nextCursor'];
} while ($cursor !== null);

cursor = nil
loop do
  query = { externalUserRef: "user_12345", limit: 50, cursor: cursor }.compact
  page = stele("GET", "/acceptances?#{URI.encode_www_form(query)}")
  page["acceptances"].each do |acceptance|
    puts "#{acceptance["acceptanceId"]} #{acceptance["versionNumber"]}"
  end
  cursor = page["nextCursor"]
  break if cursor.nil?
end

string? cursor = null;
do
{
    var query = $"externalUserRef={Uri.EscapeDataString("user_12345")}&limit=50";
    if (cursor is not null) query += $"&cursor={cursor}";
    var page = await Stele(HttpMethod.Get, $"/acceptances?{query}");
    foreach (var acceptance in page.GetProperty("acceptances").EnumerateArray())
        Console.WriteLine(acceptance.GetProperty("acceptanceId").GetString());
    cursor = page.GetProperty("nextCursor").GetString();
} while (cursor is not null);

curl "https://stele.site/api/v1/acceptances/$ACCEPTANCE_ID" \
  -H "Authorization: Bearer $STELE_API_KEY"

// The SDK encodes the ID; an unknown or foreign ID throws (404).
const { acceptance, receiptUrl } = await stele.getAcceptance(acceptanceId);

import re

if not re.fullmatch(r"[0-9a-f]{64}", acceptance_id):
    raise ValueError("invalid acceptance ID")
found = stele("GET", f"/acceptances/{acceptance_id}")
acceptance, receipt_url = found["acceptance"], found["receiptUrl"]

if (!acceptanceId.matches("[0-9a-f]{64}")) {
  throw new IllegalArgumentException("invalid acceptance ID");
}
JsonNode found = Stele.get("/acceptances/" + acceptanceId);
JsonNode acceptance = found.get("acceptance");

if !regexp.MustCompile(`^[0-9a-f]{64}$`).MatchString(acceptanceID) {
	return errors.New("invalid acceptance ID")
}
var found struct {
	Acceptance struct {
		VersionAddress  string  `json:"versionAddress"`
		ExternalUserRef *string `json:"externalUserRef"`
	} `json:"acceptance"`
	ReceiptURL string `json:"receiptUrl"`
}
if err := stele("GET", "/acceptances/"+acceptanceID, nil, &found); err != nil {
	return err
}

if (!preg_match('/^[0-9a-f]{64}$/D', $acceptanceId)) {
    throw new InvalidArgumentException('invalid acceptance ID');
}
$found = stele('GET', "/acceptances/$acceptanceId");
$acceptance = $found['acceptance'];

raise ArgumentError, "invalid acceptance ID" unless acceptance_id.match?(/\A[0-9a-f]{64}\z/)

found = stele("GET", "/acceptances/#{acceptance_id}")
acceptance = found["acceptance"]

if (!System.Text.RegularExpressions.Regex.IsMatch(acceptanceId, @"^[0-9a-f]{64}\z"))
    throw new ArgumentException("invalid acceptance ID");
var found = await Stele(HttpMethod.Get, $"/acceptances/{acceptanceId}");
var acceptance = found.GetProperty("acceptance");

curl "https://stele.site/api/v1/public/acceptances/$ACCEPTANCE_ID/receipt" \
  | jq .receipt > receipt.json

import { writeFile } from "node:fs/promises";

const res = await fetch(
  `https://stele.site/api/v1/public/acceptances/${acceptanceId}/receipt`,
);
const { receipt, report } = await res.json();
await writeFile(`${acceptanceId}.json`, JSON.stringify(receipt, null, 2));

import json

result = requests.get(f"{BASE_URL}/public/acceptances/{acceptance_id}/receipt", timeout=10)
result.raise_for_status()
with open(f"{acceptance_id}.json", "w", encoding="utf-8") as file:
    json.dump(result.json()["receipt"], file, indent=2)

JsonNode result = Stele.get("/public/acceptances/" + acceptanceId + "/receipt");
java.nio.file.Files.writeString(
    java.nio.file.Path.of(acceptanceId + ".json"), result.get("receipt").toPrettyString());

var result struct {
	Receipt json.RawMessage `json:"receipt"`
}
if err := stele("GET", "/public/acceptances/"+acceptanceID+"/receipt", nil, &result); err != nil {
	return err
}
if err := os.WriteFile(acceptanceID+".json", result.Receipt, 0o600); err != nil {
	return err
}

$result = stele('GET', "/public/acceptances/$acceptanceId/receipt");
file_put_contents("$acceptanceId.json", json_encode($result['receipt'], JSON_PRETTY_PRINT));

result = stele("GET", "/public/acceptances/#{acceptance_id}/receipt")
File.write("#{acceptance_id}.json", JSON.pretty_generate(result["receipt"]))

var result = await Stele(HttpMethod.Get, $"/public/acceptances/{acceptanceId}/receipt");
await File.WriteAllTextAsync($"{acceptanceId}.json", result.GetProperty("receipt").GetRawText());

curl "https://stele.site/api/v1/signer-identities?externalUserRef=user_12345" \
  -H "Authorization: Bearer $STELE_API_KEY"

curl "https://stele.site/api/v1/signer-identities/$PUBLIC_KEY/revoke" \
  -H "Authorization: Bearer $STELE_API_KEY" -H "Content-Type: application/json" \
  -d '{ "reason": "lost all devices; identity re-verified by support" }'

const { signers } = await stele.listSigners("user_12345");
await stele.revokeSigner(signers[0].publicKey, "lost all devices; identity re-verified by support");

signers = stele("GET", "/signer-identities", params={"externalUserRef": "user_12345"})["signers"]
stele("POST", f"/signer-identities/{signers[0]['publicKey']}/revoke",
      json={"reason": "lost all devices; identity re-verified by support"})

JsonNode signers = Stele.get("/signer-identities", Map.of("externalUserRef", "user_12345"))
    .get("signers");
Stele.post("/signer-identities/" + signers.get(0).get("publicKey").asText() + "/revoke",
    Map.of("reason", "lost all devices; identity re-verified by support"));

var found struct {
	Signers []struct {
		PublicKey string `json:"publicKey"`
		Status    string `json:"status"`
	} `json:"signers"`
}
if err := stele("GET", "/signer-identities?externalUserRef=user_12345", nil, &found); err != nil {
	return err
}
var revoked map[string]any
err := stele("POST", "/signer-identities/"+found.Signers[0].PublicKey+"/revoke",
	map[string]string{"reason": "lost all devices; identity re-verified by support"}, &revoked)
if err != nil {
	return err
}

$signers = stele('GET', '/signer-identities?externalUserRef=user_12345')['signers'];
stele('POST', "/signer-identities/{$signers[0]['publicKey']}/revoke", [
    'reason' => 'lost all devices; identity re-verified by support',
]);

signers = stele("GET", "/signer-identities?externalUserRef=user_12345")["signers"]
stele("POST", "/signer-identities/#{signers[0]["publicKey"]}/revoke",
      { reason: "lost all devices; identity re-verified by support" })

var signers = (await Stele(HttpMethod.Get, "/signer-identities?externalUserRef=user_12345"))
    .GetProperty("signers");
var publicKey = signers[0].GetProperty("publicKey").GetString();
await Stele(HttpMethod.Post, $"/signer-identities/{publicKey}/revoke",
    new { reason = "lost all devices; identity re-verified by support" });

curl https://stele.site/api/v1/proof-requests \
  -H "Authorization: Bearer $STELE_API_KEY" -H "Content-Type: application/json" \
  -d '{
    "type": "PURCHASE",
    "reference": "order-1042",
    "summary": "Purchase of 2 items from Acme",
    "details": {
      "currency": "EUR",
      "items": [{ "sku": "MUG-1", "name": "Mug", "quantity": 2, "unitPrice": "9.00", "total": "18.00" }],
      "subtotal": "18.00", "shipping": "3.90", "total": "21.90"
    },
    "externalUserRef": "user_12345"
  }'

const request = await stele.createProofRequest({
  type: "PURCHASE",
  reference: "order-1042",
  summary: "Purchase of 2 items from Acme",
  details: {
    currency: "EUR",
    items: [{ sku: "MUG-1", name: "Mug", quantity: 2, unitPrice: "9.00", total: "18.00" }],
    subtotal: "18.00",
    shipping: "3.90",
    total: "21.90",
  },
  externalUserRef: "user_12345",
});
// Send request.requestId and request.clientToken to the customer's browser

request = stele("POST", "/proof-requests", json={
    "type": "PURCHASE",
    "reference": "order-1042",
    "summary": "Purchase of 2 items from Acme",
    "details": {
        "currency": "EUR",
        "items": [{"sku": "MUG-1", "name": "Mug", "quantity": 2,
                   "unitPrice": "9.00", "total": "18.00"}],
        "subtotal": "18.00",
        "shipping": "3.90",
        "total": "21.90",
    },
    "externalUserRef": "user_12345",
})
# Send request["requestId"] and request["clientToken"] to the customer's browser

JsonNode request = Stele.post("/proof-requests", Map.of(
    "type", "PURCHASE",
    "reference", "order-1042",
    "summary", "Purchase of 2 items from Acme",
    "details", Map.of(
        "currency", "EUR",
        "items", java.util.List.of(Map.of("sku", "MUG-1", "name", "Mug", "quantity", 2,
            "unitPrice", "9.00", "total", "18.00")),
        "subtotal", "18.00",
        "shipping", "3.90",
        "total", "21.90"),
    "externalUserRef", "user_12345"));
// Send requestId and clientToken to the customer's browser
String requestId = request.get("requestId").asText();

var request struct {
	RequestID   string `json:"requestId"`
	ClientToken string `json:"clientToken"`
	ConfirmURL  string `json:"confirmUrl"`
}
err := stele("POST", "/proof-requests", map[string]any{
	"type":      "PURCHASE",
	"reference": "order-1042",
	"summary":   "Purchase of 2 items from Acme",
	"details": map[string]any{
		"currency": "EUR",
		"items": []map[string]any{{"sku": "MUG-1", "name": "Mug", "quantity": 2,
			"unitPrice": "9.00", "total": "18.00"}},
		"subtotal": "18.00",
		"shipping": "3.90",
		"total":    "21.90",
	},
	"externalUserRef": "user_12345",
}, &request)
if err != nil {
	return err
}
// Send request.RequestID and request.ClientToken to the customer's browser

$request = stele('POST', '/proof-requests', [
    'type' => 'PURCHASE',
    'reference' => 'order-1042',
    'summary' => 'Purchase of 2 items from Acme',
    'details' => [
        'currency' => 'EUR',
        'items' => [['sku' => 'MUG-1', 'name' => 'Mug', 'quantity' => 2,
                     'unitPrice' => '9.00', 'total' => '18.00']],
        'subtotal' => '18.00',
        'shipping' => '3.90',
        'total' => '21.90',
    ],
    'externalUserRef' => 'user_12345',
]);
// Send $request['requestId'] and $request['clientToken'] to the customer's browser

request = stele("POST", "/proof-requests", {
  type: "PURCHASE",
  reference: "order-1042",
  summary: "Purchase of 2 items from Acme",
  details: {
    currency: "EUR",
    items: [{ sku: "MUG-1", name: "Mug", quantity: 2, unitPrice: "9.00", total: "18.00" }],
    subtotal: "18.00",
    shipping: "3.90",
    total: "21.90",
  },
  externalUserRef: "user_12345",
})
# Send request["requestId"] and request["clientToken"] to the customer's browser

var request = await Stele(HttpMethod.Post, "/proof-requests", new
{
    type = "PURCHASE",
    reference = "order-1042",
    summary = "Purchase of 2 items from Acme",
    details = new
    {
        currency = "EUR",
        items = new[] { new { sku = "MUG-1", name = "Mug", quantity = 2, unitPrice = "9.00", total = "18.00" } },
        subtotal = "18.00",
        shipping = "3.90",
        total = "21.90",
    },
    externalUserRef = "user_12345",
});
// Send requestId and clientToken to the customer's browser
var requestId = request.GetProperty("requestId").GetString();

curl "https://stele.site/api/v1/proofs?type=PURCHASE&reference=order-1042" \
  -H "Authorization: Bearer $STELE_API_KEY"

# The receipt, verified against Solana (contains the statement: keep it private)
curl "https://stele.site/api/v1/proofs/$PROOF_ID/receipt" \
  -H "Authorization: Bearer $STELE_API_KEY"

const { proofs } = await stele.listProofs({ type: "PURCHASE", reference: "order-1042" });
const proof = proofs.find((p) => p.externalUserRef === "user_12345");
if (!proof) throw new Error("Not confirmed yet");
const { receipt, report } = await stele.getProofReceipt(proof.proofId); // verified against Solana

proofs = stele("GET", "/proofs", params={"type": "PURCHASE", "reference": "order-1042"})["proofs"]
proof = next((p for p in proofs if p["externalUserRef"] == "user_12345"), None)
if proof is None:
    raise RuntimeError("not confirmed yet")
receipt = stele("GET", f"/proofs/{proof['proofId']}/receipt")  # {receipt, report}

JsonNode proofs = Stele.get("/proofs", Map.of("type", "PURCHASE", "reference", "order-1042"))
    .get("proofs");
JsonNode proof = null;
for (JsonNode p : proofs) {
  if ("user_12345".equals(p.get("externalUserRef").asText())) proof = p;
}
if (proof == null) throw new IllegalStateException("not confirmed yet");
JsonNode receipt = Stele.get("/proofs/" + proof.get("proofId").asText() + "/receipt");

var found struct {
	Proofs []struct {
		ProofID         string  `json:"proofId"`
		ExternalUserRef *string `json:"externalUserRef"`
	} `json:"proofs"`
}
if err := stele("GET", "/proofs?type=PURCHASE&reference=order-1042", nil, &found); err != nil {
	return err
}
proofID := ""
for _, p := range found.Proofs {
	if p.ExternalUserRef != nil && *p.ExternalUserRef == "user_12345" {
		proofID = p.ProofID
	}
}
if proofID == "" {
	return errors.New("not confirmed yet")
}
var receipt map[string]any // {receipt, report}
if err := stele("GET", "/proofs/"+proofID+"/receipt", nil, &receipt); err != nil {
	return err
}

$proofs = stele('GET', '/proofs?type=PURCHASE&reference=order-1042')['proofs'];
$matches = array_filter($proofs, fn ($p) => $p['externalUserRef'] === 'user_12345');
if (!$matches) {
    throw new RuntimeException('not confirmed yet');
}
$receipt = stele('GET', '/proofs/' . reset($matches)['proofId'] . '/receipt');

proofs = stele("GET", "/proofs?type=PURCHASE&reference=order-1042")["proofs"]
proof = proofs.find { |p| p["externalUserRef"] == "user_12345" } or raise "not confirmed yet"
receipt = stele("GET", "/proofs/#{proof["proofId"]}/receipt") # {receipt, report}

var proofs = (await Stele(HttpMethod.Get, "/proofs?type=PURCHASE&reference=order-1042"))
    .GetProperty("proofs").EnumerateArray();
var proof = proofs.FirstOrDefault(p => p.GetProperty("externalUserRef").GetString() == "user_12345");
if (proof.ValueKind == JsonValueKind.Undefined) throw new InvalidOperationException("not confirmed yet");
var receipt = await Stele(HttpMethod.Get, $"/proofs/{proof.GetProperty("proofId").GetString()}/receipt");