List claims

Lists the effective claims the caller may read, each labelled with the org that made it and the user who recorded it.

GET /v1/benchmark/claims

Benchmark → · All API references → · Get started →

Address	`https://api.hanzo.ai/v1/benchmark/claims`
Method	`GET`
Operation	`get_benchmark_claims`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Lists the effective claims the caller may read, each labelled with the org that made it and the user who recorded it.

Anyone reads the public claims. A signed-in caller also reads its own org's private ones. No caller reads another org's private claims — a SuperAdmin acting in that org included, since acting in an org is not membership of it. Rows under org "admin" are the platform's own curated readings: the compiled seed and any correction a SuperAdmin wrote.

Effective values only. The history of a key lives in the append-only file and is not what this op is for; a list that returned every superseded row would make the common question the hard one.

Request

6 fields.

Field	In	Type	Required	Description
`Benchmark`	query	string	—	Benchmark filters to one benchmark id.
`Model`	query	string	—	Model filters to one model.
`Provider`	query	string	—	Provider filters to one lab or leaderboard — the way to read what a single source claims across every model it covers.
`Source`	query	string	—	Source filters to one citation, which is the finest grain there is: a source is what makes two claims about one model independent rather than a restatement of each other.
`Protocol`	query	string	—	Protocol filters by HOW a claim was scored, so provider cards can be read apart from third parties running their own harness.
`Org`	query	string	—	Org filters to the claims one org made; "admin" reads the platform's own.

Response

Status	Body	Meaning
`200`	benchmark.claimsOut	ok
`default`	problem-details	refused

200 body — 13 fields.

Field	In	Type	Always	Description
`data`	body	benchmark.ClaimRow[]	—	Data is one row per (org, benchmark, model, SOURCE) — every independent claim, not one per model.
`data[].at`	body	string (date-time)	—	At is when a stored row was recorded.
`data[].benchmark`	body	string	—	Benchmark is the canonical test id the claim is about, from /catalog.
`data[].by`	body	string	—	By is the verified user who recorded a stored row.
`data[].model`	body	string	—	Model is the system the score is claimed for.
`data[].org`	body	string	—	Org is the org that made the claim.
`data[].origin`	body	string	—	Origin is "seed" for a compiled row, "stored" for one a verified caller wrote through this surface, and "unattributed" for a stored row no verified caller vouches for, which never reaches the leaderboard.
`data[].protocol`	body	string	—	Protocol records HOW it was scored — provider-reported, agentic, third-party-leaderboard — so a provider card is never read as a measurement.
`data[].provider`	body	string	—	Provider is who the claim belongs to — the lab or leaderboard whose number this is.
`data[].score`	body	number (double)	—	Score is the reported aggregate, as a percentage.
`data[].source`	body	string	—	Source is the citation the row was read from.
`data[].visibility`	body	string	—	Visibility is "public", readable by anyone, or "private", readable by Org's own members only.
`total`	body	integer (int64)	—	Total is how many rows Data holds.

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo benchmark claims get

.ts

.py

.go

.rs

.java

import { Configuration, BenchmarkApi } from 'hanzoai';

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

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

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = BenchmarkApi(client).get_benchmark_claims()

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

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

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

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

let result = benchmark_api::get_benchmark_claims(&cfg, Default::default()).await?;

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

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

var result = new BenchmarkApi(client).getBenchmarkClaims();

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

MCP reaches benchmark through the benchmark tool, which names its 9 operations with its own verbs — this one among them, under a name only MCP declares. describe explains any of them:

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

Benchmark API · All Hanzo APIs · Interactive reference

Was this page useful?

PreviousList catalog NextList compare