List label

Reads the assertions this tenant has recorded, newest event first.

GET /v1/label

Label → · All API references → · Get started →

Address	`https://api.hanzo.ai/v1/label`
Method	`GET`
Operation	`riskLabels`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Reads the assertions this tenant has recorded, newest event first.

It reads the RECORD — the tenant's own store — and not the columnar copy, so what it returns is what would be produced in an audit. Narrow it by entity, by asserter, or by event window.

Request

6 fields.

Field	In	Type	Required	Description
`kind`	query	string	—	Kind and Subject narrow to one entity.
`subject`	query	string	—
`source`	query	string	—	Source narrows to one asserter — the read that answers "what has commerce told us", separately from "what has an analyst told us".
`from`	query	string	—	From and To bound the EVENT time, half-open, RFC 3339.
`to`	query	string	—
`limit`	query	integer	—	Limit caps the page.

Response

Status	Body	Meaning
`200`	label.riskLabelsOut	ok
`default`	problem-details	refused

200 body — 15 fields.

Field	In	Type	Always	Description
`count`	body	integer (int64)	—	Count is how many this page holds.
`labels`	body	label.riskLabelRecord[]	—	Labels is the page, newest event first.
`labels[].at`	body	string	—	At is when the judged EVENT happened, RFC 3339 in UTC, truncated to the second.
`labels[].by`	body	string	—	By is the identity that asserted, stamped server-side at the write.
`labels[].confidence`	body	number (double)	—	Confidence is the filer's own confidence in [0,1] — 1 for a processor chargeback, less for an analyst's hunch.
`labels[].disposition`	body	string	—	Disposition is what was concluded, from the closed set: `productive` — the event led somewhere, escalated, reported or charged back; `unproductive` — judged not suspicious; or the empty string for an explicit UNJUDGED, which is a real assertion ("we looked and could not say") and not the absence of one.
`labels[].evidence`	body	string	—	Evidence is the pointer to the record this conclusion came from: a dispute id, a case id, a decision id.
`labels[].hold`	body	boolean	—	Hold is true while a litigation hold is on this record: retention will not dispose of it, at any age.
`labels[].id`	body	string	—	ID is the assertion's content digest — SHA-256 over every semantic field, rendered hex — computed server-side and never supplied.
`labels[].kind`	body	string	—	Kind is what the subject IS, from the closed set: account, agent, merchant, payout, person, session or transaction.
`labels[].knowable`	body	string	—	Knowable is when THIS PLANE could first have answered with the assertion: the later of Seen and the server clock at the write, derived server-side.
`labels[].seen`	body	string	—	Seen is when the FILER said the assertion became knowable.
`labels[].source`	body	string	—	Source is WHO asserted, from the closed set: chargeoff, dispute, case, refund, review or sample.
`labels[].subject`	body	string	—	Subject is the entity that was judged, named in the TENANT'S OWN namespace and at most 512 bytes.
`labels[].wrote`	body	string	—	Wrote is the server clock at the write.

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo label get

.ts

.py

.go

.rs

.java

import { Configuration, LabelApi } from 'hanzoai';

const api = new LabelApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.riskLabels();

from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import LabelApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = LabelApi(client).risk_labels()

cfg := hanzoai.NewConfiguration()
cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY"))
client := hanzoai.NewAPIClient(cfg)

resp, _, err := client.LabelAPI.RiskLabels(context.Background()).Execute()
if err != nil {
	return err
}

use hanzo_client::apis::{configuration::Configuration, label_api};

let mut cfg = Configuration::new();
cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok();

let result = label_api::risk_labels(&cfg, Default::default()).await?;

import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.LabelApi;

ApiClient client = new ApiClient();
client.setBearerToken(System.getenv("HANZO_API_KEY"));

var result = new LabelApi(client).riskLabels();

curl https://api.hanzo.ai/v1/label \
  -H "Authorization: Bearer $HANZO_API_KEY"

Tool label, op riskLabels — POST the JSON-RPC envelope to https://api.hanzo.ai/v1/mcp.

curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "label",
         "arguments": {
           "op": "riskLabels",
           "input": {}
         }
       }
     }'

Label API · All Hanzo APIs · Interactive reference

Was this page useful?

PreviousList coverage NextList vocabulary