QAVE Docs

API Reference

Interactive OpenAPI playground for /evaluate and /v1/assure/*.

Machine-readable OpenAPI lives at /docs/openapi.json. For agents, prefer /docs/llms.txt.

Use the Try-it playground below with a Bearer API key from Get Free API Key. Requests are proxied through /docs/api/proxy to avoid browser CORS issues.

Studio-only session routes (SSO, avatar, API-key reveal, pending reviews, pairwise preferences) and removed JSONL batch endpoints are intentionally omitted from this playground.

Run assurance evaluation (unified)

POST
/evaluate

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Request Body

application/jsonRequired
evaluate_kindstring

Optional when messages or trace is present (auto-inferred).

Value in: "conversation" | "agent_trace"
messagesarray<object>
traceobject

Agent trace envelope (agent_trace).

criteriaarray<string>
rubric_idstring
rubric_idsarray<string>
assurance_tierstring
Default: "flash"Value in: "flash" | "pro" | "lightning"
modestring

Optional alias for assurance_tier

external_idstring
test_case_idstring
metadataobject
evaluate_latestboolean
voice_telemetryobject
voice_metadataobject
voice_turnsarray<object>
artifactsobject
kb_idstring
sourcesobject

Toggle retrieval sources at evaluate time.

ground_truthstring | object

Optional reference answer or expected structured state.

tagsobject

Flat str tags (max 10 keys); filter with ?tag=key:value

Response Body

Evaluation result

TypeScript Definitions

Use the response body type in TypeScript.

scorenumber
statusstring
trace_idstring
confidencenumber
quality_labelstring
explanationstring
sources_usedobject
kb_chunks_usedarray<object>

@minItems 0

tagsobject
pass_threshold_taunumber
credits_chargednumber
[key: string]any
curl -X POST "https://qurator.qapitol.ai/evaluate" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "evaluate_kind": "conversation",
    "messages": [
      {
        "role": "system",
        "content": "string",
        "name": "string",
        "tool_call_id": "string"
      }
    ],
    "trace": {},
    "criteria": [
      "string"
    ],
    "rubric_id": "string",
    "rubric_ids": [
      "string"
    ],
    "assurance_tier": "flash",
    "mode": "string",
    "external_id": "string",
    "test_case_id": "string",
    "metadata": {},
    "evaluate_latest": true,
    "voice_telemetry": {},
    "voice_metadata": {},
    "voice_turns": [
      {}
    ],
    "artifacts": {},
    "kb_id": "string",
    "sources": {
      "documents": true,
      "annotations": true,
      "memory": true,
      "calibration_tau": true,
      "property1": true,
      "property2": true
    },
    "ground_truth": "string",
    "tags": {
      "property1": "string",
      "property2": "string"
    }
  }'
const body = JSON.stringify({
  "evaluate_kind": "conversation",
  "messages": [
    {
      "role": "system",
      "content": "string",
      "name": "string",
      "tool_call_id": "string"
    }
  ],
  "trace": {},
  "criteria": [
    "string"
  ],
  "rubric_id": "string",
  "rubric_ids": [
    "string"
  ],
  "assurance_tier": "flash",
  "mode": "string",
  "external_id": "string",
  "test_case_id": "string",
  "metadata": {},
  "evaluate_latest": true,
  "voice_telemetry": {},
  "voice_metadata": {},
  "voice_turns": [
    {}
  ],
  "artifacts": {},
  "kb_id": "string",
  "sources": {
    "documents": true,
    "annotations": true,
    "memory": true,
    "calibration_tau": true,
    "property1": true,
    "property2": true
  },
  "ground_truth": "string",
  "tags": {
    "property1": "string",
    "property2": "string"
  }
})

fetch("https://qurator.qapitol.ai/evaluate", {
  headers: {
    "Authorization": "Bearer <token>"
  },
  body
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
  "strings"
)

func main() {
  url := "https://qurator.qapitol.ai/evaluate"
  body := strings.NewReader(`{
    "evaluate_kind": "conversation",
    "messages": [
      {
        "role": "system",
        "content": "string",
        "name": "string",
        "tool_call_id": "string"
      }
    ],
    "trace": {},
    "criteria": [
      "string"
    ],
    "rubric_id": "string",
    "rubric_ids": [
      "string"
    ],
    "assurance_tier": "flash",
    "mode": "string",
    "external_id": "string",
    "test_case_id": "string",
    "metadata": {},
    "evaluate_latest": true,
    "voice_telemetry": {},
    "voice_metadata": {},
    "voice_turns": [
      {}
    ],
    "artifacts": {},
    "kb_id": "string",
    "sources": {
      "documents": true,
      "annotations": true,
      "memory": true,
      "calibration_tau": true,
      "property1": true,
      "property2": true
    },
    "ground_truth": "string",
    "tags": {
      "property1": "string",
      "property2": "string"
    }
  }`)
  req, _ := http.NewRequest("POST", url, body)
  req.Header.Add("Authorization", "Bearer <token>")
  req.Header.Add("Content-Type", "application/json")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/evaluate"
body = {
  "evaluate_kind": "conversation",
  "messages": [
    {
      "role": "system",
      "content": "string",
      "name": "string",
      "tool_call_id": "string"
    }
  ],
  "trace": {},
  "criteria": [
    "string"
  ],
  "rubric_id": "string",
  "rubric_ids": [
    "string"
  ],
  "assurance_tier": "flash",
  "mode": "string",
  "external_id": "string",
  "test_case_id": "string",
  "metadata": {},
  "evaluate_latest": true,
  "voice_telemetry": {},
  "voice_metadata": {},
  "voice_turns": [
    {}
  ],
  "artifacts": {},
  "kb_id": "string",
  "sources": {
    "documents": true,
    "annotations": true,
    "memory": true,
    "calibration_tau": true,
    "property1": true,
    "property2": true
  },
  "ground_truth": "string",
  "tags": {
    "property1": "string",
    "property2": "string"
  }
}
response = requests.request("POST", url, json = body, headers = {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
})

print(response.text)
{
  "score": 0,
  "status": "string",
  "trace_id": "string",
  "confidence": 0,
  "quality_label": "string",
  "explanation": "string",
  "sources_used": {
    "property1": true,
    "property2": true
  },
  "kb_chunks_used": [
    {}
  ],
  "tags": {
    "property1": "string",
    "property2": "string"
  },
  "pass_threshold_tau": 0,
  "credits_charged": 0
}

Run assurance evaluation (assure namespace)

POST
/v1/assure/evaluate

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Request Body

application/jsonRequired
evaluate_kindstring

Optional when messages or trace is present (auto-inferred).

Value in: "conversation" | "agent_trace"
messagesarray<object>
traceobject

Agent trace envelope (agent_trace).

criteriaarray<string>
rubric_idstring
rubric_idsarray<string>
assurance_tierstring
Default: "flash"Value in: "flash" | "pro" | "lightning"
modestring

Optional alias for assurance_tier

external_idstring
test_case_idstring
metadataobject
evaluate_latestboolean
voice_telemetryobject
voice_metadataobject
voice_turnsarray<object>
artifactsobject
kb_idstring
sourcesobject

Toggle retrieval sources at evaluate time.

ground_truthstring | object

Optional reference answer or expected structured state.

tagsobject

Flat str tags (max 10 keys); filter with ?tag=key:value

Response Body

Evaluation result

TypeScript Definitions

Use the response body type in TypeScript.

scorenumber
statusstring
trace_idstring
confidencenumber
quality_labelstring
explanationstring
sources_usedobject
kb_chunks_usedarray<object>

@minItems 0

tagsobject
pass_threshold_taunumber
credits_chargednumber
[key: string]any
curl -X POST "https://qurator.qapitol.ai/v1/assure/evaluate" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "evaluate_kind": "conversation",
    "messages": [
      {
        "role": "system",
        "content": "string",
        "name": "string",
        "tool_call_id": "string"
      }
    ],
    "trace": {},
    "criteria": [
      "string"
    ],
    "rubric_id": "string",
    "rubric_ids": [
      "string"
    ],
    "assurance_tier": "flash",
    "mode": "string",
    "external_id": "string",
    "test_case_id": "string",
    "metadata": {},
    "evaluate_latest": true,
    "voice_telemetry": {},
    "voice_metadata": {},
    "voice_turns": [
      {}
    ],
    "artifacts": {},
    "kb_id": "string",
    "sources": {
      "documents": true,
      "annotations": true,
      "memory": true,
      "calibration_tau": true,
      "property1": true,
      "property2": true
    },
    "ground_truth": "string",
    "tags": {
      "property1": "string",
      "property2": "string"
    }
  }'
const body = JSON.stringify({
  "evaluate_kind": "conversation",
  "messages": [
    {
      "role": "system",
      "content": "string",
      "name": "string",
      "tool_call_id": "string"
    }
  ],
  "trace": {},
  "criteria": [
    "string"
  ],
  "rubric_id": "string",
  "rubric_ids": [
    "string"
  ],
  "assurance_tier": "flash",
  "mode": "string",
  "external_id": "string",
  "test_case_id": "string",
  "metadata": {},
  "evaluate_latest": true,
  "voice_telemetry": {},
  "voice_metadata": {},
  "voice_turns": [
    {}
  ],
  "artifacts": {},
  "kb_id": "string",
  "sources": {
    "documents": true,
    "annotations": true,
    "memory": true,
    "calibration_tau": true,
    "property1": true,
    "property2": true
  },
  "ground_truth": "string",
  "tags": {
    "property1": "string",
    "property2": "string"
  }
})

fetch("https://qurator.qapitol.ai/v1/assure/evaluate", {
  headers: {
    "Authorization": "Bearer <token>"
  },
  body
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
  "strings"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/evaluate"
  body := strings.NewReader(`{
    "evaluate_kind": "conversation",
    "messages": [
      {
        "role": "system",
        "content": "string",
        "name": "string",
        "tool_call_id": "string"
      }
    ],
    "trace": {},
    "criteria": [
      "string"
    ],
    "rubric_id": "string",
    "rubric_ids": [
      "string"
    ],
    "assurance_tier": "flash",
    "mode": "string",
    "external_id": "string",
    "test_case_id": "string",
    "metadata": {},
    "evaluate_latest": true,
    "voice_telemetry": {},
    "voice_metadata": {},
    "voice_turns": [
      {}
    ],
    "artifacts": {},
    "kb_id": "string",
    "sources": {
      "documents": true,
      "annotations": true,
      "memory": true,
      "calibration_tau": true,
      "property1": true,
      "property2": true
    },
    "ground_truth": "string",
    "tags": {
      "property1": "string",
      "property2": "string"
    }
  }`)
  req, _ := http.NewRequest("POST", url, body)
  req.Header.Add("Authorization", "Bearer <token>")
  req.Header.Add("Content-Type", "application/json")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/evaluate"
body = {
  "evaluate_kind": "conversation",
  "messages": [
    {
      "role": "system",
      "content": "string",
      "name": "string",
      "tool_call_id": "string"
    }
  ],
  "trace": {},
  "criteria": [
    "string"
  ],
  "rubric_id": "string",
  "rubric_ids": [
    "string"
  ],
  "assurance_tier": "flash",
  "mode": "string",
  "external_id": "string",
  "test_case_id": "string",
  "metadata": {},
  "evaluate_latest": true,
  "voice_telemetry": {},
  "voice_metadata": {},
  "voice_turns": [
    {}
  ],
  "artifacts": {},
  "kb_id": "string",
  "sources": {
    "documents": true,
    "annotations": true,
    "memory": true,
    "calibration_tau": true,
    "property1": true,
    "property2": true
  },
  "ground_truth": "string",
  "tags": {
    "property1": "string",
    "property2": "string"
  }
}
response = requests.request("POST", url, json = body, headers = {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
})

print(response.text)
{
  "score": 0,
  "status": "string",
  "trace_id": "string",
  "confidence": 0,
  "quality_label": "string",
  "explanation": "string",
  "sources_used": {
    "property1": true,
    "property2": true
  },
  "kb_chunks_used": [
    {}
  ],
  "tags": {
    "property1": "string",
    "property2": "string"
  },
  "pass_threshold_tau": 0,
  "credits_charged": 0
}

Evaluate maintenance / availability status

Public read of evaluate availability (no API key required).

GET
/v1/assure/evaluate-status

Response Body

Maintenance status

TypeScript Definitions

Use the response body type in TypeScript.

[key: string]any
curl -X GET "https://qurator.qapitol.ai/v1/assure/evaluate-status"
fetch("https://qurator.qapitol.ai/v1/assure/evaluate-status")
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/evaluate-status"

  req, _ := http.NewRequest("GET", url, nil)
  
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/evaluate-status"

response = requests.request("GET", url)

print(response.text)
{}

Validate and preview a trace envelope

POST
/v1/assure/trace/preview

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Request Body

application/jsonRequired
traceRequiredobject

Response Body

Normalized preview

TypeScript Definitions

Use the response body type in TypeScript.

validboolean
messagesarray<object>
errorsarray<string>
curl -X POST "https://qurator.qapitol.ai/v1/assure/trace/preview" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "trace": {}
  }'
const body = JSON.stringify({
  "trace": {}
})

fetch("https://qurator.qapitol.ai/v1/assure/trace/preview", {
  headers: {
    "Authorization": "Bearer <token>"
  },
  body
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
  "strings"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/trace/preview"
  body := strings.NewReader(`{
    "trace": {}
  }`)
  req, _ := http.NewRequest("POST", url, body)
  req.Header.Add("Authorization", "Bearer <token>")
  req.Header.Add("Content-Type", "application/json")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/trace/preview"
body = {
  "trace": {}
}
response = requests.request("POST", url, json = body, headers = {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
})

print(response.text)
{
  "valid": true,
  "messages": [
    {
      "role": "system",
      "content": "string",
      "name": "string",
      "tool_call_id": "string"
    }
  ],
  "errors": [
    "string"
  ]
}

List evaluation history

GET
/v1/assure/history/evaluations

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Query Parameters

limitinteger
Default: 50Minimum: 1Maximum: 200
offsetinteger
Default: 0Minimum: 0
typestring

Filter: conversation | trace | agent_trace

batchstring

Filter by jsonl_batch_id

in_batchstring

yes = only JSONL batch lines; no = only non-batch runs

Value in: "yes" | "no"
searchstring

Trace id or external_id substring

statusstring
Value in: "pass" | "warning" | "fail"
qualitystring
Value in: "high" | "medium" | "low" | "uncertain"
date_fromstring

Inclusive start date (YYYY-MM-DD)

Format: "date"
date_tostring

Inclusive end date (YYYY-MM-DD)

Format: "date"

Response Body

Evaluation list

TypeScript Definitions

Use the response body type in TypeScript.

evaluationsarray<object>
countinteger
offsetinteger
limitinteger
curl -X GET "https://qurator.qapitol.ai/v1/assure/history/evaluations?limit=50&offset=0&type=string&batch=string&in_batch=yes&search=string&status=pass&quality=high&date_from=2019-08-24&date_to=2019-08-24" \
  -H "Authorization: Bearer <token>"
fetch("https://qurator.qapitol.ai/v1/assure/history/evaluations?limit=50&offset=0&type=string&batch=string&in_batch=yes&search=string&status=pass&quality=high&date_from=2019-08-24&date_to=2019-08-24", {
  headers: {
    "Authorization": "Bearer <token>"
  }
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/history/evaluations?limit=50&offset=0&type=string&batch=string&in_batch=yes&search=string&status=pass&quality=high&date_from=2019-08-24&date_to=2019-08-24"

  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Add("Authorization", "Bearer <token>")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/history/evaluations?limit=50&offset=0&type=string&batch=string&in_batch=yes&search=string&status=pass&quality=high&date_from=2019-08-24&date_to=2019-08-24"

response = requests.request("GET", url, headers = {
  "Authorization": "Bearer <token>"
})

print(response.text)
{
  "evaluations": [
    {
      "id": "string",
      "type": "string",
      "score": 0,
      "confidence": 0,
      "criteria_count": 0,
      "rubric_id": "string",
      "credits_charged": 0,
      "created_at": "string",
      "external_id": "string",
      "jsonl_batch_id": "string",
      "jsonl_line": 0,
      "jsonl_total": 0,
      "jsonl_kind": "string",
      "model_used": "string",
      "review_recommended": true,
      "score_explanation_divergence": true
    }
  ],
  "count": 0,
  "offset": 0,
  "limit": 0
}

List evaluation batches

GET
/v1/assure/history/batches

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Query Parameters

limitinteger
Default: 50Minimum: 1Maximum: 200
offsetinteger
Default: 0Minimum: 0
searchstring
date_fromstring
Format: "date"
date_tostring
Format: "date"
outcomestring
Value in: "any_failure" | "all_ready" | "partial"
kindstring
Value in: "conversation" | "trace"

Response Body

Batch list

TypeScript Definitions

Use the response body type in TypeScript.

batchesarray<object>
countinteger
offsetinteger
limitinteger
curl -X GET "https://qurator.qapitol.ai/v1/assure/history/batches?limit=50&offset=0&search=string&date_from=2019-08-24&date_to=2019-08-24&outcome=any_failure&kind=conversation" \
  -H "Authorization: Bearer <token>"
fetch("https://qurator.qapitol.ai/v1/assure/history/batches?limit=50&offset=0&search=string&date_from=2019-08-24&date_to=2019-08-24&outcome=any_failure&kind=conversation", {
  headers: {
    "Authorization": "Bearer <token>"
  }
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/history/batches?limit=50&offset=0&search=string&date_from=2019-08-24&date_to=2019-08-24&outcome=any_failure&kind=conversation"

  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Add("Authorization", "Bearer <token>")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/history/batches?limit=50&offset=0&search=string&date_from=2019-08-24&date_to=2019-08-24&outcome=any_failure&kind=conversation"

response = requests.request("GET", url, headers = {
  "Authorization": "Bearer <token>"
})

print(response.text)
{
  "batches": [
    {
      "batch_id": "string",
      "kind": "string",
      "line_count": 0,
      "jsonl_total": 0,
      "partial": true,
      "ready_count": 0,
      "fail_count": 0,
      "mean_score": 0,
      "credits_sum": 0,
      "created_at_min": "string"
    }
  ],
  "count": 0,
  "offset": 0,
  "limit": 0
}

Get evaluation detail

GET
/v1/assure/history/evaluations/{evaluation_id}

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Path Parameters

evaluation_idRequiredstring

Response Body

Evaluation detail

TypeScript Definitions

Use the response body type in TypeScript.

idstring
typestring
scorenumber
confidencenumber
quality_labelstring | null | null
explanationstring
evidence_forarray<string>
evidence_againstarray<string>
gapsarray<string>
severitystring | null | null
score_explanation_divergenceboolean
review_recommendedboolean
model_usedstring | null | null
credits_chargednumber | null | null
created_atstring
raw_submitted_jsonobject
feedback_votestring | null | null
rubric_scoresarray<object> | null | null
pass_threshold_taunumber | null | null
[key: string]any
curl -X GET "https://qurator.qapitol.ai/v1/assure/history/evaluations/string" \
  -H "Authorization: Bearer <token>"
fetch("https://qurator.qapitol.ai/v1/assure/history/evaluations/string", {
  headers: {
    "Authorization": "Bearer <token>"
  }
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/history/evaluations/string"

  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Add("Authorization", "Bearer <token>")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/history/evaluations/string"

response = requests.request("GET", url, headers = {
  "Authorization": "Bearer <token>"
})

print(response.text)
{
  "id": "string",
  "type": "string",
  "score": 0,
  "confidence": 0,
  "quality_label": "string",
  "explanation": "string",
  "evidence_for": [
    "string"
  ],
  "evidence_against": [
    "string"
  ],
  "gaps": [
    "string"
  ],
  "severity": "string",
  "score_explanation_divergence": true,
  "review_recommended": true,
  "model_used": "string",
  "credits_charged": 0,
  "created_at": "string",
  "raw_submitted_json": {},
  "feedback_vote": "string",
  "rubric_scores": [
    {}
  ],
  "pass_threshold_tau": 0
}

Submit human feedback (confirm / override)

Accessible via API key. When include_in_tau applies, may trigger progressive τ* update.

POST
/v1/assure/feedback

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Request Body

application/jsonRequired
trace_idRequiredstring
votestring

Legacy signal. Prefer action=confirm|override.

Default: "up"Value in: "up" | "down"
actionstring
Value in: "confirm" | "override"
sme_verdictstring
Value in: "pass" | "fail"
reason_tagstring
Value in: "missed_violation" | "false_alarm" | "rubric_wording"
categorystring
Maximum length: 64
commentstring
Maximum length: 500
skip_pairwiseboolean
Default: true

Response Body

Feedback recorded

TypeScript Definitions

Use the response body type in TypeScript.

feedback_idstring
trace_idstring
golden_kindstring
Value in: "golden_signal"
signal_votestring
Value in: "up" | "down"
sme_verdictstring | null | null
Value in: "pass" | "fail"
reason_tagstring | null | null
include_in_tauboolean
calibration_updateobject | null | null
curl -X POST "https://qurator.qapitol.ai/v1/assure/feedback" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "trace_id": "string",
    "vote": "up",
    "action": "confirm",
    "sme_verdict": "pass",
    "reason_tag": "missed_violation",
    "category": "string",
    "comment": "string",
    "skip_pairwise": true
  }'
const body = JSON.stringify({
  "trace_id": "string",
  "vote": "up",
  "action": "confirm",
  "sme_verdict": "pass",
  "reason_tag": "missed_violation",
  "category": "string",
  "comment": "string",
  "skip_pairwise": true
})

fetch("https://qurator.qapitol.ai/v1/assure/feedback", {
  headers: {
    "Authorization": "Bearer <token>"
  },
  body
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
  "strings"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/feedback"
  body := strings.NewReader(`{
    "trace_id": "string",
    "vote": "up",
    "action": "confirm",
    "sme_verdict": "pass",
    "reason_tag": "missed_violation",
    "category": "string",
    "comment": "string",
    "skip_pairwise": true
  }`)
  req, _ := http.NewRequest("POST", url, body)
  req.Header.Add("Authorization", "Bearer <token>")
  req.Header.Add("Content-Type", "application/json")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/feedback"
body = {
  "trace_id": "string",
  "vote": "up",
  "action": "confirm",
  "sme_verdict": "pass",
  "reason_tag": "missed_violation",
  "category": "string",
  "comment": "string",
  "skip_pairwise": true
}
response = requests.request("POST", url, json = body, headers = {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
})

print(response.text)
{
  "feedback_id": "string",
  "trace_id": "string",
  "golden_kind": "golden_signal",
  "signal_vote": "up",
  "sme_verdict": "pass",
  "reason_tag": "string",
  "include_in_tau": true,
  "calibration_update": {}
}

Get progressive τ* calibration status

GET
/v1/assure/calibration

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Query Parameters

assurance_tierstring
Value in: "flash" | "pro" | "lightning"
rubric_idstring

Response Body

Calibration status

TypeScript Definitions

Use the response body type in TypeScript.

operating_pointsarray<object>

@minItems 0

uploaded_examples_countinteger
knowledge_bases_countinteger
client_idstring
tenant_idstring | null | null
curl -X GET "https://qurator.qapitol.ai/v1/assure/calibration?assurance_tier=flash&rubric_id=string" \
  -H "Authorization: Bearer <token>"
fetch("https://qurator.qapitol.ai/v1/assure/calibration?assurance_tier=flash&rubric_id=string", {
  headers: {
    "Authorization": "Bearer <token>"
  }
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/calibration?assurance_tier=flash&rubric_id=string"

  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Add("Authorization", "Bearer <token>")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/calibration?assurance_tier=flash&rubric_id=string"

response = requests.request("GET", url, headers = {
  "Authorization": "Bearer <token>"
})

print(response.text)
{
  "operating_points": [
    {
      "assurance_tier": "string",
      "rubric_id": "string",
      "calibration_stage": "string",
      "tau_star": 0,
      "default_tau": 0,
      "raw_tau_candidate": 0,
      "shrinkage_lambda": 0,
      "n_pass": 0,
      "n_fail": 0,
      "sample_size": 0,
      "method": "string",
      "source": "string",
      "min_verdicts_for_eb": 0,
      "min_fail_for_crc": 0
    }
  ],
  "uploaded_examples_count": 0,
  "knowledge_bases_count": 0,
  "client_id": "string",
  "tenant_id": "string"
}

Get progressive τ* calibration status (alias)

GET
/v1/assure/calibration/status

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Query Parameters

assurance_tierstring
Value in: "flash" | "pro" | "lightning"
rubric_idstring

Response Body

Calibration status

TypeScript Definitions

Use the response body type in TypeScript.

operating_pointsarray<object>

@minItems 0

uploaded_examples_countinteger
knowledge_bases_countinteger
client_idstring
tenant_idstring | null | null
curl -X GET "https://qurator.qapitol.ai/v1/assure/calibration/status?assurance_tier=flash&rubric_id=string" \
  -H "Authorization: Bearer <token>"
fetch("https://qurator.qapitol.ai/v1/assure/calibration/status?assurance_tier=flash&rubric_id=string", {
  headers: {
    "Authorization": "Bearer <token>"
  }
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/calibration/status?assurance_tier=flash&rubric_id=string"

  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Add("Authorization", "Bearer <token>")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/calibration/status?assurance_tier=flash&rubric_id=string"

response = requests.request("GET", url, headers = {
  "Authorization": "Bearer <token>"
})

print(response.text)
{
  "operating_points": [
    {
      "assurance_tier": "string",
      "rubric_id": "string",
      "calibration_stage": "string",
      "tau_star": 0,
      "default_tau": 0,
      "raw_tau_candidate": 0,
      "shrinkage_lambda": 0,
      "n_pass": 0,
      "n_fail": 0,
      "sample_size": 0,
      "method": "string",
      "source": "string",
      "min_verdicts_for_eb": 0,
      "min_fail_for_crc": 0
    }
  ],
  "uploaded_examples_count": 0,
  "knowledge_bases_count": 0,
  "client_id": "string",
  "tenant_id": "string"
}

Recompute tenant operating point (τ*)

POST
/v1/assure/calibration/recompute

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Request Body

application/jsonOptional
assurance_tierstring
Default: "pro"Value in: "flash" | "pro" | "lightning"
rubric_idstring
target_alphanumber
Default: 0.05

Response Body

Updated operating point

TypeScript Definitions

Use the response body type in TypeScript.

[key: string]any
curl -X POST "https://qurator.qapitol.ai/v1/assure/calibration/recompute" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "assurance_tier": "flash",
    "rubric_id": "string",
    "target_alpha": 0.05
  }'
const body = JSON.stringify({
  "assurance_tier": "flash",
  "rubric_id": "string",
  "target_alpha": 0.05
})

fetch("https://qurator.qapitol.ai/v1/assure/calibration/recompute", {
  headers: {
    "Authorization": "Bearer <token>"
  },
  body
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
  "strings"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/calibration/recompute"
  body := strings.NewReader(`{
    "assurance_tier": "flash",
    "rubric_id": "string",
    "target_alpha": 0.05
  }`)
  req, _ := http.NewRequest("POST", url, body)
  req.Header.Add("Authorization", "Bearer <token>")
  req.Header.Add("Content-Type", "application/json")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/calibration/recompute"
body = {
  "assurance_tier": "flash",
  "rubric_id": "string",
  "target_alpha": 0.05
}
response = requests.request("POST", url, json = body, headers = {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
})

print(response.text)
{}

List built-in and custom rubrics

GET
/v1/assure/rubrics

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Query Parameters

limitinteger
Default: 100Minimum: 1Maximum: 200
offsetinteger
Default: 0Minimum: 0

Response Body

Rubric catalog

TypeScript Definitions

Use the response body type in TypeScript.

rubricsarray<object>
countinteger
offsetinteger
limitinteger
curl -X GET "https://qurator.qapitol.ai/v1/assure/rubrics?limit=100&offset=0" \
  -H "Authorization: Bearer <token>"
fetch("https://qurator.qapitol.ai/v1/assure/rubrics?limit=100&offset=0", {
  headers: {
    "Authorization": "Bearer <token>"
  }
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/rubrics?limit=100&offset=0"

  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Add("Authorization", "Bearer <token>")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/rubrics?limit=100&offset=0"

response = requests.request("GET", url, headers = {
  "Authorization": "Bearer <token>"
})

print(response.text)
{
  "rubrics": [
    {
      "id": "string",
      "name": "string",
      "category": "string",
      "criteria": [
        "string"
      ],
      "gating": true,
      "is_custom": true,
      "knowledge_base_id": "string"
    }
  ],
  "count": 0,
  "offset": 0,
  "limit": 0
}

Create a custom rubric

Freemium cap: 3 active custom rubrics. Paid: unlimited.

POST
/v1/assure/rubrics

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Request Body

application/jsonRequired
idstring
nameRequiredstring
criteriaRequiredarray<string>
categorystring
Default: "custom"
gatingboolean
Default: true
knowledge_base_idstring

Response Body

Created rubric

TypeScript Definitions

Use the response body type in TypeScript.

idstring
namestring
categorystring
criteriaarray<string>

@minItems 0

@minItems 0

gatingboolean
is_customboolean
knowledge_base_idstring | null | null
curl -X POST "https://qurator.qapitol.ai/v1/assure/rubrics" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "id": "string",
    "name": "string",
    "criteria": [
      "string"
    ],
    "category": "custom",
    "gating": true,
    "knowledge_base_id": "string"
  }'
const body = JSON.stringify({
  "id": "string",
  "name": "string",
  "criteria": [
    "string"
  ],
  "category": "custom",
  "gating": true,
  "knowledge_base_id": "string"
})

fetch("https://qurator.qapitol.ai/v1/assure/rubrics", {
  headers: {
    "Authorization": "Bearer <token>"
  },
  body
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
  "strings"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/rubrics"
  body := strings.NewReader(`{
    "id": "string",
    "name": "string",
    "criteria": [
      "string"
    ],
    "category": "custom",
    "gating": true,
    "knowledge_base_id": "string"
  }`)
  req, _ := http.NewRequest("POST", url, body)
  req.Header.Add("Authorization", "Bearer <token>")
  req.Header.Add("Content-Type", "application/json")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/rubrics"
body = {
  "id": "string",
  "name": "string",
  "criteria": [
    "string"
  ],
  "category": "custom",
  "gating": true,
  "knowledge_base_id": "string"
}
response = requests.request("POST", url, json = body, headers = {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
})

print(response.text)
{
  "id": "string",
  "name": "string",
  "category": "string",
  "criteria": [
    "string"
  ],
  "gating": true,
  "is_custom": true,
  "knowledge_base_id": "string"
}

Update a custom rubric

PUT
/v1/assure/rubrics/{rubric_id}

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Request Body

application/jsonRequired
namestring
criteriaarray<string>
gatingboolean
knowledge_base_idstring

Path Parameters

rubric_idRequiredstring

Response Body

Updated rubric

TypeScript Definitions

Use the response body type in TypeScript.

idstring
namestring
categorystring
criteriaarray<string>

@minItems 0

@minItems 0

gatingboolean
is_customboolean
knowledge_base_idstring | null | null
curl -X PUT "https://qurator.qapitol.ai/v1/assure/rubrics/string" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "string",
    "criteria": [
      "string"
    ],
    "gating": true,
    "knowledge_base_id": "string"
  }'
const body = JSON.stringify({
  "name": "string",
  "criteria": [
    "string"
  ],
  "gating": true,
  "knowledge_base_id": "string"
})

fetch("https://qurator.qapitol.ai/v1/assure/rubrics/string", {
  headers: {
    "Authorization": "Bearer <token>"
  },
  body
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
  "strings"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/rubrics/string"
  body := strings.NewReader(`{
    "name": "string",
    "criteria": [
      "string"
    ],
    "gating": true,
    "knowledge_base_id": "string"
  }`)
  req, _ := http.NewRequest("PUT", url, body)
  req.Header.Add("Authorization", "Bearer <token>")
  req.Header.Add("Content-Type", "application/json")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/rubrics/string"
body = {
  "name": "string",
  "criteria": [
    "string"
  ],
  "gating": true,
  "knowledge_base_id": "string"
}
response = requests.request("PUT", url, json = body, headers = {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
})

print(response.text)
{
  "id": "string",
  "name": "string",
  "category": "string",
  "criteria": [
    "string"
  ],
  "gating": true,
  "is_custom": true,
  "knowledge_base_id": "string"
}

Soft-delete a custom rubric

Platform built-in rubrics return 403.

DELETE
/v1/assure/rubrics/{rubric_id}

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Path Parameters

rubric_idRequiredstring

Response Body

Deleted

TypeScript Definitions

Use the response body type in TypeScript.

deletedboolean
rubric_idstring
curl -X DELETE "https://qurator.qapitol.ai/v1/assure/rubrics/string" \
  -H "Authorization: Bearer <token>"
fetch("https://qurator.qapitol.ai/v1/assure/rubrics/string", {
  headers: {
    "Authorization": "Bearer <token>"
  }
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/rubrics/string"

  req, _ := http.NewRequest("DELETE", url, nil)
  req.Header.Add("Authorization", "Bearer <token>")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/rubrics/string"

response = requests.request("DELETE", url, headers = {
  "Authorization": "Bearer <token>"
})

print(response.text)
{
  "deleted": true,
  "rubric_id": "string"
}

Upload example evaluations (batch)

PII-redacted golden labels; 0 credits. Freemium cap 25 total; Paid unlimited (500/batch).

POST
/v1/assure/annotations/batch

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Request Body

application/jsonRequired
examplesRequiredarray<object>
assurance_tierstring
Default: "pro"Value in: "flash" | "pro" | "lightning"

Response Body

Upload result

TypeScript Definitions

Use the response body type in TypeScript.

uploaded_countinteger
pii_redactions_appliedinteger
trace_idsarray<string>
calibration_updateobject | null | null
curl -X POST "https://qurator.qapitol.ai/v1/assure/annotations/batch" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "examples": [
      {
        "messages": [
          {
            "role": "system",
            "content": "string",
            "name": "string",
            "tool_call_id": "string"
          }
        ],
        "criteria": [
          "string"
        ],
        "verdict": "pass",
        "sme_verdict": "pass",
        "rationale": "string",
        "comment": "string",
        "reason_tag": "string",
        "score": 0,
        "rubric_id": "string",
        "rubric_ids": [
          "string"
        ],
        "input_text": "string",
        "output_text": "string"
      }
    ],
    "assurance_tier": "flash"
  }'
const body = JSON.stringify({
  "examples": [
    {
      "messages": [
        {
          "role": "system",
          "content": "string",
          "name": "string",
          "tool_call_id": "string"
        }
      ],
      "criteria": [
        "string"
      ],
      "verdict": "pass",
      "sme_verdict": "pass",
      "rationale": "string",
      "comment": "string",
      "reason_tag": "string",
      "score": 0,
      "rubric_id": "string",
      "rubric_ids": [
        "string"
      ],
      "input_text": "string",
      "output_text": "string"
    }
  ],
  "assurance_tier": "flash"
})

fetch("https://qurator.qapitol.ai/v1/assure/annotations/batch", {
  headers: {
    "Authorization": "Bearer <token>"
  },
  body
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
  "strings"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/annotations/batch"
  body := strings.NewReader(`{
    "examples": [
      {
        "messages": [
          {
            "role": "system",
            "content": "string",
            "name": "string",
            "tool_call_id": "string"
          }
        ],
        "criteria": [
          "string"
        ],
        "verdict": "pass",
        "sme_verdict": "pass",
        "rationale": "string",
        "comment": "string",
        "reason_tag": "string",
        "score": 0,
        "rubric_id": "string",
        "rubric_ids": [
          "string"
        ],
        "input_text": "string",
        "output_text": "string"
      }
    ],
    "assurance_tier": "flash"
  }`)
  req, _ := http.NewRequest("POST", url, body)
  req.Header.Add("Authorization", "Bearer <token>")
  req.Header.Add("Content-Type", "application/json")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/annotations/batch"
body = {
  "examples": [
    {
      "messages": [
        {
          "role": "system",
          "content": "string",
          "name": "string",
          "tool_call_id": "string"
        }
      ],
      "criteria": [
        "string"
      ],
      "verdict": "pass",
      "sme_verdict": "pass",
      "rationale": "string",
      "comment": "string",
      "reason_tag": "string",
      "score": 0,
      "rubric_id": "string",
      "rubric_ids": [
        "string"
      ],
      "input_text": "string",
      "output_text": "string"
    }
  ],
  "assurance_tier": "flash"
}
response = requests.request("POST", url, json = body, headers = {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
})

print(response.text)
{
  "uploaded_count": 0,
  "pii_redactions_applied": 0,
  "trace_ids": [
    "string"
  ],
  "calibration_update": {}
}

List uploaded example evaluations

GET
/v1/assure/annotations

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Query Parameters

rubric_idstring

Response Body

Annotation list

TypeScript Definitions

Use the response body type in TypeScript.

annotationsarray<object>
countinteger
curl -X GET "https://qurator.qapitol.ai/v1/assure/annotations?rubric_id=string" \
  -H "Authorization: Bearer <token>"
fetch("https://qurator.qapitol.ai/v1/assure/annotations?rubric_id=string", {
  headers: {
    "Authorization": "Bearer <token>"
  }
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/annotations?rubric_id=string"

  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Add("Authorization", "Bearer <token>")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/annotations?rubric_id=string"

response = requests.request("GET", url, headers = {
  "Authorization": "Bearer <token>"
})

print(response.text)
{
  "annotations": [
    {
      "trace_id": "string",
      "score": 0,
      "criteria": [
        "string"
      ],
      "created_at": "string",
      "rubric_id": "string"
    }
  ],
  "count": 0
}

Delete an uploaded example evaluation

DELETE
/v1/assure/annotations/{trace_id}

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Path Parameters

trace_idRequiredstring

Response Body

Deleted

TypeScript Definitions

Use the response body type in TypeScript.

deletedboolean
trace_idstring
calibration_updateobject
curl -X DELETE "https://qurator.qapitol.ai/v1/assure/annotations/string" \
  -H "Authorization: Bearer <token>"
fetch("https://qurator.qapitol.ai/v1/assure/annotations/string", {
  headers: {
    "Authorization": "Bearer <token>"
  }
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/annotations/string"

  req, _ := http.NewRequest("DELETE", url, nil)
  req.Header.Add("Authorization", "Bearer <token>")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/annotations/string"

response = requests.request("DELETE", url, headers = {
  "Authorization": "Bearer <token>"
})

print(response.text)
{
  "deleted": true,
  "trace_id": "string",
  "calibration_update": {}
}

List knowledge bases

GET
/v1/assure/knowledge-bases

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Response Body

KB list

TypeScript Definitions

Use the response body type in TypeScript.

knowledge_basesarray<object>
countinteger
curl -X GET "https://qurator.qapitol.ai/v1/assure/knowledge-bases" \
  -H "Authorization: Bearer <token>"
fetch("https://qurator.qapitol.ai/v1/assure/knowledge-bases", {
  headers: {
    "Authorization": "Bearer <token>"
  }
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/knowledge-bases"

  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Add("Authorization", "Bearer <token>")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/knowledge-bases"

response = requests.request("GET", url, headers = {
  "Authorization": "Bearer <token>"
})

print(response.text)
{
  "knowledge_bases": [
    {
      "id": "string",
      "name": "string",
      "description": "string",
      "document_count": 0,
      "chunk_count": 0,
      "total_bytes": 0,
      "attached_rubric_ids": [
        "string"
      ],
      "created_at": "string"
    }
  ],
  "count": 0
}

Create a knowledge base

Freemium cap: 1 KB. Paid: unlimited.

POST
/v1/assure/knowledge-bases

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Request Body

application/jsonRequired
nameRequiredstring
descriptionstring

Response Body

Created KB

TypeScript Definitions

Use the response body type in TypeScript.

idstring
namestring
descriptionstring | null | null
document_countinteger
chunk_countinteger
total_bytesinteger
attached_rubric_idsarray<string>

@minItems 0

created_atstring | null | null
curl -X POST "https://qurator.qapitol.ai/v1/assure/knowledge-bases" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "string",
    "description": "string"
  }'
const body = JSON.stringify({
  "name": "string",
  "description": "string"
})

fetch("https://qurator.qapitol.ai/v1/assure/knowledge-bases", {
  headers: {
    "Authorization": "Bearer <token>"
  },
  body
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
  "strings"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/knowledge-bases"
  body := strings.NewReader(`{
    "name": "string",
    "description": "string"
  }`)
  req, _ := http.NewRequest("POST", url, body)
  req.Header.Add("Authorization", "Bearer <token>")
  req.Header.Add("Content-Type", "application/json")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/knowledge-bases"
body = {
  "name": "string",
  "description": "string"
}
response = requests.request("POST", url, json = body, headers = {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
})

print(response.text)
{
  "id": "string",
  "name": "string",
  "description": "string",
  "document_count": 0,
  "chunk_count": 0,
  "total_bytes": 0,
  "attached_rubric_ids": [
    "string"
  ],
  "created_at": "string"
}

Upload a document to a knowledge base

Accepts JSON {filename, content, mime_type} or multipart file. Formats: .md/.txt/.pdf/.docx. PII redacted per chunk.

POST
/v1/assure/knowledge-bases/{kb_id}/documents

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Request Body

application/jsonRequired
filenamestring
Default: "document.md"
contentstring
mime_typestring

Path Parameters

kb_idRequiredstring

Response Body

Upload / dedup result

TypeScript Definitions

Use the response body type in TypeScript.

document_idstring
statusstring
Value in: "ready" | "deduplicated"
chunk_countinteger
pii_redactions_countinteger
sha256_digeststring
curl -X POST "https://qurator.qapitol.ai/v1/assure/knowledge-bases/string/documents" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "filename": "document.md",
    "content": "string",
    "mime_type": "string"
  }'
const body = JSON.stringify({
  "filename": "document.md",
  "content": "string",
  "mime_type": "string"
})

fetch("https://qurator.qapitol.ai/v1/assure/knowledge-bases/string/documents", {
  headers: {
    "Authorization": "Bearer <token>"
  },
  body
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
  "strings"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/knowledge-bases/string/documents"
  body := strings.NewReader(`{
    "filename": "document.md",
    "content": "string",
    "mime_type": "string"
  }`)
  req, _ := http.NewRequest("POST", url, body)
  req.Header.Add("Authorization", "Bearer <token>")
  req.Header.Add("Content-Type", "application/json")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/knowledge-bases/string/documents"
body = {
  "filename": "document.md",
  "content": "string",
  "mime_type": "string"
}
response = requests.request("POST", url, json = body, headers = {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
})

print(response.text)
{
  "document_id": "string",
  "status": "ready",
  "chunk_count": 0,
  "pii_redactions_count": 0,
  "sha256_digest": "string"
}

Delete a KB document

DELETE
/v1/assure/knowledge-bases/{kb_id}/documents/{doc_id}

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Path Parameters

kb_idRequiredstring
doc_idRequiredstring

Response Body

Deleted

TypeScript Definitions

Use the response body type in TypeScript.

deletedboolean
document_idstring
curl -X DELETE "https://qurator.qapitol.ai/v1/assure/knowledge-bases/string/documents/string" \
  -H "Authorization: Bearer <token>"
fetch("https://qurator.qapitol.ai/v1/assure/knowledge-bases/string/documents/string", {
  headers: {
    "Authorization": "Bearer <token>"
  }
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/knowledge-bases/string/documents/string"

  req, _ := http.NewRequest("DELETE", url, nil)
  req.Header.Add("Authorization", "Bearer <token>")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/knowledge-bases/string/documents/string"

response = requests.request("DELETE", url, headers = {
  "Authorization": "Bearer <token>"
})

print(response.text)
{
  "deleted": true,
  "document_id": "string"
}

Delete a knowledge base

Returns 409 if attached to an active rubric or non-empty unless force=true.

DELETE
/v1/assure/knowledge-bases/{kb_id}

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Path Parameters

kb_idRequiredstring

Query Parameters

forceboolean
Default: false

Response Body

Deleted

TypeScript Definitions

Use the response body type in TypeScript.

deletedboolean
kb_idstring
curl -X DELETE "https://qurator.qapitol.ai/v1/assure/knowledge-bases/string?force=false" \
  -H "Authorization: Bearer <token>"
fetch("https://qurator.qapitol.ai/v1/assure/knowledge-bases/string?force=false", {
  headers: {
    "Authorization": "Bearer <token>"
  }
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/knowledge-bases/string?force=false"

  req, _ := http.NewRequest("DELETE", url, nil)
  req.Header.Add("Authorization", "Bearer <token>")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/knowledge-bases/string?force=false"

response = requests.request("DELETE", url, headers = {
  "Authorization": "Bearer <token>"
})

print(response.text)
{
  "deleted": true,
  "kb_id": "string"
}

Insights KPI overview

GET
/v1/assure/insights/overview

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Query Parameters

window_daysinteger
Default: 7Minimum: 1Maximum: 90
group_by_tagstring

Response Body

Overview KPIs

TypeScript Definitions

Use the response body type in TypeScript.

[key: string]any
curl -X GET "https://qurator.qapitol.ai/v1/assure/insights/overview?window_days=7&group_by_tag=string" \
  -H "Authorization: Bearer <token>"
fetch("https://qurator.qapitol.ai/v1/assure/insights/overview?window_days=7&group_by_tag=string", {
  headers: {
    "Authorization": "Bearer <token>"
  }
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/insights/overview?window_days=7&group_by_tag=string"

  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Add("Authorization", "Bearer <token>")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/insights/overview?window_days=7&group_by_tag=string"

response = requests.request("GET", url, headers = {
  "Authorization": "Bearer <token>"
})

print(response.text)
{}

Causal failure mode clusters

Freemium: top 3 clusters in full; clusters #4+ locked. Paid: all clusters.

GET
/v1/assure/insights/clusters

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Query Parameters

window_daysinteger
Default: 7Minimum: 1Maximum: 90
rubric_idstring

Response Body

Clusters

TypeScript Definitions

Use the response body type in TypeScript.

clustersarray<object>
countinteger
curl -X GET "https://qurator.qapitol.ai/v1/assure/insights/clusters?window_days=7&rubric_id=string" \
  -H "Authorization: Bearer <token>"
fetch("https://qurator.qapitol.ai/v1/assure/insights/clusters?window_days=7&rubric_id=string", {
  headers: {
    "Authorization": "Bearer <token>"
  }
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/insights/clusters?window_days=7&rubric_id=string"

  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Add("Authorization", "Bearer <token>")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/insights/clusters?window_days=7&rubric_id=string"

response = requests.request("GET", url, headers = {
  "Authorization": "Bearer <token>"
})

print(response.text)
{
  "clusters": [
    {}
  ],
  "count": 0
}

Promote a failure cluster to a rubric

Paid plan only (403 on Freemium).

POST
/v1/assure/insights/clusters/{cluster_id}/promote-rubric

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Request Body

application/jsonOptional
namestring
rubric_idstring

Path Parameters

cluster_idRequiredstring

Response Body

Created rubric

TypeScript Definitions

Use the response body type in TypeScript.

rubric_idstring
namestring
criteriaarray<string>
curl -X POST "https://qurator.qapitol.ai/v1/assure/insights/clusters/string/promote-rubric" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "string",
    "rubric_id": "string"
  }'
const body = JSON.stringify({
  "name": "string",
  "rubric_id": "string"
})

fetch("https://qurator.qapitol.ai/v1/assure/insights/clusters/string/promote-rubric", {
  headers: {
    "Authorization": "Bearer <token>"
  },
  body
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
  "strings"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/insights/clusters/string/promote-rubric"
  body := strings.NewReader(`{
    "name": "string",
    "rubric_id": "string"
  }`)
  req, _ := http.NewRequest("POST", url, body)
  req.Header.Add("Authorization", "Bearer <token>")
  req.Header.Add("Content-Type", "application/json")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/insights/clusters/string/promote-rubric"
body = {
  "name": "string",
  "rubric_id": "string"
}
response = requests.request("POST", url, json = body, headers = {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
})

print(response.text)
{
  "rubric_id": "string",
  "name": "string",
  "criteria": [
    "string"
  ]
}

Get credit usage for the current month

GET
/v1/assure/usage/credits

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Response Body

Credits

TypeScript Definitions

Use the response body type in TypeScript.

monthstring
allowancenumber
usednumber
remainingnumber
eval_countinteger
reset_notestring
curl -X GET "https://qurator.qapitol.ai/v1/assure/usage/credits" \
  -H "Authorization: Bearer <token>"
fetch("https://qurator.qapitol.ai/v1/assure/usage/credits", {
  headers: {
    "Authorization": "Bearer <token>"
  }
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/usage/credits"

  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Add("Authorization", "Bearer <token>")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/usage/credits"

response = requests.request("GET", url, headers = {
  "Authorization": "Bearer <token>"
})

print(response.text)
{
  "month": "string",
  "allowance": 0,
  "used": 0,
  "remaining": 0,
  "eval_count": 0,
  "reset_note": "string"
}

Get workspace context for the API key

GET
/v1/assure/workspace

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Response Body

Workspace

TypeScript Definitions

Use the response body type in TypeScript.

org_namestring
tenant_idstring
client_idstring
project_idstring
plan_codestring
allowed_assurance_tiersarray<string>
calibration_anchors_usedinteger
calibration_anchor_capinteger | null | null
calibration_writes_enabledboolean
[key: string]any
curl -X GET "https://qurator.qapitol.ai/v1/assure/workspace" \
  -H "Authorization: Bearer <token>"
fetch("https://qurator.qapitol.ai/v1/assure/workspace", {
  headers: {
    "Authorization": "Bearer <token>"
  }
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/workspace"

  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Add("Authorization", "Bearer <token>")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/workspace"

response = requests.request("GET", url, headers = {
  "Authorization": "Bearer <token>"
})

print(response.text)
{
  "org_name": "string",
  "tenant_id": "string",
  "client_id": "string",
  "project_id": "string",
  "plan_code": "string",
  "allowed_assurance_tiers": [
    "string"
  ],
  "calibration_anchors_used": 0,
  "calibration_anchor_cap": 0,
  "calibration_writes_enabled": true
}

Read-only MCP JSON-RPC 2.0

Streamable HTTP JSON-RPC (initialize, tools/list, tools/call). Tools: list_rubrics, list_traces, get_calibration, get_insights, get_failure_clusters, list_tag_keys, list_tag_values.

POST
/v1/assure/mcp

Authorization

AuthorizationRequiredBearer <token>

Studio API key (Authorization: Bearer <key>).

In: header

Request Body

application/jsonRequired
jsonrpcRequiredstring
Value in: "2.0"
idunknown
methodRequiredstring
paramsobject

Response Body

JSON-RPC response

TypeScript Definitions

Use the response body type in TypeScript.

[key: string]any
curl -X POST "https://qurator.qapitol.ai/v1/assure/mcp" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": null,
    "method": "string",
    "params": {}
  }'
const body = JSON.stringify({
  "jsonrpc": "2.0",
  "id": null,
  "method": "string",
  "params": {}
})

fetch("https://qurator.qapitol.ai/v1/assure/mcp", {
  headers: {
    "Authorization": "Bearer <token>"
  },
  body
})
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
  "strings"
)

func main() {
  url := "https://qurator.qapitol.ai/v1/assure/mcp"
  body := strings.NewReader(`{
    "jsonrpc": "2.0",
    "id": null,
    "method": "string",
    "params": {}
  }`)
  req, _ := http.NewRequest("POST", url, body)
  req.Header.Add("Authorization", "Bearer <token>")
  req.Header.Add("Content-Type", "application/json")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  body, _ := ioutil.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}
import requests

url = "https://qurator.qapitol.ai/v1/assure/mcp"
body = {
  "jsonrpc": "2.0",
  "id": null,
  "method": "string",
  "params": {}
}
response = requests.request("POST", url, json = body, headers = {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
})

print(response.text)
{}

Insights & MCP

Causal failure clustering, tag slices, and the read-only MCP server.

Quickstart

Run your first assurance evaluation in five minutes.