From signup to a verified, spend-capped integration.

curl -X POST https://sentiqra.tech/v1/analyze \
  -H "Authorization: Bearer $SENTIQRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "you are a worthless idiot",
    "language": "en",
    "analyzers": [
        "trust-safety"
    ]
}'

import os
import requests

response = requests.post(
    "https://sentiqra.tech/v1/analyze",
    headers={
        "Authorization": f"Bearer {os.environ['SENTIQRA_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={
            "text": "you are a worthless idiot",
            "language": "en",
            "analyzers": ["trust-safety"],
        },
    timeout=10,
)

response.raise_for_status()
data = response.json()

for signal in data["signals"]:
    print(signal["label"], f"{signal['score']:.0%}")

print("Analyzer runs billed:", data["usage"]["analyzer_runs"])
print("Fingerprint:", data["verification"]["fingerprint"])

const response = await fetch("https://sentiqra.tech/v1/analyze", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.SENTIQRA_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
          text: "you are a worthless idiot",
          language: "en",
          analyzers: ["trust-safety"],
        }),
});

const data = await response.json();

for (const signal of data.signals) {
  console.log(signal.label, `${(signal.score * 100).toFixed(0)}%`);
}

console.log("Analyzer runs billed:", data.usage.analyzer_runs);
console.log("Fingerprint:", data.verification.fingerprint);

package main

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

func main() {
    body := `{"text":"you are a worthless idiot","language":"en","analyzers":["trust-safety"]}`
    req, _ := http.NewRequest("POST", "https://sentiqra.tech/v1/analyze", strings.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("SENTIQRA_API_KEY"))
    req.Header.Set("Content-Type", "application/json")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    var data struct {
        Language string `json:"language"`
        Signals  []struct {
            Analyzer string  `json:"analyzer"`
            Code     string  `json:"code"`
            Label    string  `json:"label"`
            Score    float64 `json:"score"`
            Level    string  `json:"level"`
            Parent   string  `json:"parent,omitempty"`
        } `json:"signals"`
        Usage struct {
            AnalyzerRuns int `json:"analyzer_runs"`
        } `json:"usage"`
        Verification struct {
            Fingerprint string `json:"fingerprint"`
        } `json:"verification"`
    }
    raw, _ := io.ReadAll(resp.Body)
    json.Unmarshal(raw, &data)

    for _, signal := range data.Signals {
        fmt.Printf("%s %.0f%%
", signal.Label, signal.Score*100)
    }

    fmt.Println("Analyzer runs billed:", data.Usage.AnalyzerRuns)
    fmt.Println("Fingerprint:", data.Verification.Fingerprint)
}

<?php

$response = Http::withToken(env('SENTIQRA_API_KEY'))
    ->timeout(10)
    ->post('https://sentiqra.tech/v1/analyze', [
            'text' => 'you are a worthless idiot',
            'language' => 'en',
            'analyzers' => ['trust-safety'],
        ]);

$data = $response->json();

foreach ($data['signals'] as $signal) {
    echo $signal['label'] . ' ' . round($signal['score'] * 100) . "%
";
}

echo "Analyzer runs billed: " . $data['usage']['analyzer_runs'] . "
";
echo "Fingerprint: " . $data['verification']['fingerprint'] . "
";

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;

public class SentiqraExample {
    public static void main(String[] args) throws Exception {
        String apiKey = System.getenv("SENTIQRA_API_KEY");
        String baseUrl = "https://sentiqra.tech";

        String jsonBody = """
            {
                "text": "you are a worthless idiot",
                "language": "en",
                "analyzers": [
                    "trust-safety"
                ]
            }
            """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(baseUrl + "/v1/analyze"))
            .header("Authorization", "Bearer " + apiKey)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonBody, StandardCharsets.UTF_8))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println("Status: " + response.statusCode());
        System.out.println("Response: " + response.body());
    }
}

require 'net/http'
require 'json'
require 'uri'

api_key = ENV.fetch('SENTIQRA_API_KEY')
uri = URI("https://sentiqra.tech/v1/analyze")

request = Net::HTTP::Post.new(uri)
request['Authorization'] = "Bearer \#{api_key}"
request['Content-Type'] = 'application/json'
request.body = JSON.generate({
    text: "you are a worthless idiot",
    language: "en",
    analyzers: ["trust-safety"],
  })

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

data = JSON.parse(response.body)
data["signals"].each do |signal|
  puts "\#{signal['label']}: \#{(signal['score'] * 100).round}%"
end

puts "Analyzer runs billed: \#{data['usage']['analyzer_runs']}"
puts "Fingerprint: \#{data['verification']['fingerprint']}"

The POST /v1/analyze endpoint accepts the same minimal input for every analyzer:

{
    "text": "you are a worthless idiot",
    "language": "en",
    "analyzers": [
        "trust-safety"
    ]
}

analyzers is required - pass 1–2 explicit analyzer slugs. There is no "run everything" option and no model, temperature, threshold or Top-K parameter to configure.

text accepts up to 4,096 Unicode code points (counted after stripping surrounding whitespace). Input is validated as submitted (no normalization, never truncated); longer input returns 400 input_too_long. Longer material is prepared customer-side: each chunk is analyzed independently, every analyzed chunk consumes analyzer runs, and per-chunk signals describe only the snippet submitted - not the whole document. To keep the transformation reproducible (boundaries, normalization, overlap, receipts), use the versioned contract in Input Preparation. See API Reference → Text Limits.

{
    "language": "en",
    "language_source": "declared",
    "signals": [
        {
            "analyzer": "trust-safety",
            "code": "insults_derogation",
            "label": "Insults & Derogation",
            "score": 0.9,
            "level": "category",
            "confidence": "very_high"
        },
        {
            "analyzer": "trust-safety",
            "code": "insult",
            "label": "Insult",
            "score": 0.9,
            "level": "label",
            "parent": "insults_derogation",
            "confidence": "very_high"
        },
        {
            "analyzer": "trust-safety",
            "code": "belittling",
            "label": "Belittling",
            "score": 0.9,
            "level": "label",
            "parent": "insults_derogation",
            "confidence": "very_high"
        }
    ],
    "meta": {
        "analyzers": [
            {
                "name": "trust-safety",
                "status": "completed",
                "applicability": "analyzable",
                "assessment": "signals_detected",
                "signal_count": 3,
                "billed": true
            }
        ]
    },
    "usage": {
        "analyzer_runs": 1,
        "billed": true
    },
    "verification": {
        "version": 3,
        "configuration": "sqcfg_ZZW77NM9",
        "fingerprint": "fp2_8a72c4...19f",
        "input_commitment": "ic3_31bd5e...a42",
        "signature": "sig_ed25519_4c1f...e2a",
        "key_id": "edk_af4f218e",
        "binding_key_id": "bk_31bd5e42f7a019c8"
    },
    "output_profile": "reduced.v1"
}

version:          3
configuration:    sqcfg_ZZW77NM9
fingerprint:      fp2_8a72c4...19f
input_commitment: ic3_31bd5e...a42
signature:        sig_ed25519_4c1f...e2a
key_id:           edk_af4f218e
binding_key_id:   bk_31bd5e42f7a019c8

Signals concept → · Verification spec →

"meta": { "analyzers": [
  { "name": "trust-safety",  "status": "completed",      "applicability": "analyzable",
    "assessment": "signals_detected", "signal_count": 1, "billed": true },
  { "name": "cybersecurity", "status": "not_applicable", "applicability": "unsupported_language",
    "signal_count": 0, "billed": false }
] },
"language_source": "declared",
"usage": { "analyzer_runs": 1, "billed": true }

curl -s https://sentiqra.tech/v1/status

# → { "status": "operational", "domains": {
#      "trust-safety": { "state": "operational",
#        "configuration": "sqcfg_ZZW77NM9" }, … } }

Send detection_config to pin the configuration a request runs against. The value is an opaque sqcfg_* identifier copied from verification.configuration in a previous response, or from GET /v1/status for the current configuration of each analyzer.

A configuration ID is scoped to an analyzer set: a single analyzer slug, or the canonical sorted set a multi-analyzer request produced (the composite scope in its receipt). A pin is valid only for the exact analyzer set in the request - submitting a single-analyzer ID for a two-analyzer request, or a different analyzer's ID, is a scope mismatch. Output profile (full/reduced) and language do not change the configuration.

When detection_config is omitted the request runs the current configuration for the requested analyzer set. Omission never selects a historical configuration and never carries a previous request's pin forward.

Configuration lifecycle

The current configuration is immutable while it is current. Configurations that rotate out remain supported historical for the window published in the changelog entry that introduced their successor; on Enterprise agreements the support window is a contractual commitment for the life of the contract - subject to the security-suspension rule below, which can pause execution (never verification) of any configuration while it applies.

Replay an analysis using its original input and supported configuration ID. Configuration availability follows the published support policy or your contract.

Security suspension

A configuration pins LOGICAL behavior, not a permanently running build. When a dependency, runtime, or deployment component serving a configuration becomes unsafe, a confirmed security_vulnerability incident may suspend execution of the affected scope: pinned and unpinned requests that would execute it fail with configuration_suspended; nothing is substituted and no different detector answers in its place. Execution resumes only after the patched build passes the compatibility attestation path (reproducibility report proving the configuration's promised behavior is unchanged), or the configuration is retired through the documented lifecycle with notice. Where neither is immediately possible, a narrowly-scoped replay arrangement - an isolated deployment approved per engagement - may serve historical replay while the suspended build stays out of the general path. Receipt verification is independent of execution: a suspended or retired configuration's receipts still verify against the published key set - /v1/verify performs cryptographic verification, never re-execution, so availability of one never depends on the other.

Pinning errors

A rejected pin fails the request before any analyzer run executes and is never billed. The current configuration is never silently substituted.

Replaying an analysis

1. Run an analysis. The receipt names the configuration that produced it in verification.configuration.
2. Replay the same input with that ID in detection_config.
3. Compare the canonical result: identical language, identical signals (order, codes, scores), and identical verification.configuration.

curl -s https://sentiqra.tech/v1/analyze \
  -H "Authorization: Bearer $SENTIQRA_API_KEY" -H "Content-Type: application/json" \
  -d '{"text": "you are a worthless idiot", "language": "en", "analyzers": ["trust-safety"]}'

# → "verification": { "configuration": "sqcfg_ZZW77NM9", "fingerprint": "fp2_…", … }

curl -s https://sentiqra.tech/v1/analyze \
  -H "Authorization: Bearer $SENTIQRA_API_KEY" -H "Content-Type: application/json" \
  -d '{"text": "you are a worthless idiot", "language": "en", "analyzers": ["trust-safety"], "detection_config": "sqcfg_ZZW77NM9"}'

# → same signals and the same verification.configuration.

Replay is guaranteed while the configuration remains current or supported historical under the published support policy or your contract — not indefinitely, and subject to the security-suspension rule: an unsafe execution environment pauses execution (never receipt verification) until a patched build passes compatibility attestation.

You can also look up the current alias for an analyzer set without spending a run: GET https://sentiqra.tech/v1/config/alias?scope=trust-safety.

curl -s https://sentiqra.tech/v1/verify \
  -H "Content-Type: application/json" \
  -d '{
    "fingerprint": "fp2_8a72c4...19f",
    "input_commitment": "ic3_31bd5e...a42",
    "signature": "sig_ed25519_4c1f...e2a"
  }'

# → { "valid": true, "signature_valid": true,
#     "fingerprint_match": "not_checked",
#     "input_commitment": "not_checked", … }

Prefer a point-and-click check? The standalone verifier checks receipts offline in your browser (test vectors: receipt-test-vectors.json), or use the verification tool under Dashboard → Verify. A dedicated receipt-verification package is planned separately from the SDKs - today, /v1/verify and the offline public key are the supported path. See the receipt spec for field details.

API Keys → your key → Production Controls → Spending budget → Edit

Enter a monthly USD amount (or set it at creation with the Spend cap field). Once the key's billed spend reaches the cap, further requests are rejected until the next billing period. Leave it empty to remove the cap.

Put the result into a workflow

Signals are evidence - your code turns them into a decision. Route on the stable code and a threshold your policy owns:

# pseudocode - shape depends on your stack; SDKs are in preview
resp = analyze(text, language="en", analyzers=["trust-safety"])
run  = resp.meta.analyzers["trust-safety"]

# A signal only exists if the analyzer actually ran on this input.
if run.status != "completed" or run.assessment != "signals_detected":
    route(run.status)                     # your triage for empty/failed runs
elif any(s.code == "threat" and s.score >= 0.90 for s in resp.signals):
    review_queue.enqueue(message_id)
elif any(s.code == "insult" and s.score >= 0.80 for s in resp.signals):
    moderation_queue.enqueue(message_id)
else:
    publish(message_id)

Thresholds above are illustrative. Validate them against your own labeled data and policy before production. See Policy Decisions & Appeals for a runnable, versioned policy evaluator, and the Production Guide for retries, idempotency, and partial-result handling.

Same integration, every analyzer

The authentication method and request body stay the same - just change the analyzers parameter:

"analyzers": ["trust-safety"]        // harmful-language signals
"analyzers": ["cybersecurity"]       // phishing & threat signals
"analyzers": ["customer-service"]    // support-ticket signals
"analyzers": ["trust-safety", "cybersecurity"]  // two per request, max

One key, one endpoint - upgrading your plan doesn't change the integration. Full catalog: all 12 production analyzers →