Create claims

POST /v1/benchmark/claims

Records claims for the caller's org: one to correct a number, many to import a leaderboard. Any signed-in caller may write; a caller with no verified principal is refused 401.

The org and the author are the verified caller's. Nothing in the body names either, and a body that tries is not read. Claims are private to that org unless visibility is "public". Writing as org "admin" curates the leaderboard, so it takes a SuperAdmin; anyone else acting there is refused 403, and the refusal is audited.

Every row must carry a Source, because a claim without its citation is a number nobody can check, and a benchmark id from /catalog, because an unknown id would sit in the store invisible to every read. A row names its benchmark, model, provider and protocol in at most 128 characters each, cites a source of at most 2048 bytes, and scores a percentage from 0 to 100; a row outside that is rejected by number.

A request carries at most 500 rows in at most 1 MiB (413 past either), and an org writes at most 2000 rows per UTC day (429 past that, and nothing from the request is written).

The trail takes the call's intent, naming every row, BEFORE the first row lands; a trail that cannot take it answers 503 and nothing is written. A second record then names which rows were stored and which failed.

Writes are append-only, so this never destroys the value it replaces. A vendor restating a score leaves both rows on disk, which is how the restating itself becomes visible.

Request

8 fields, body application/json (required).

Response

200 body — 4 fields.

Failure carries the platform error shape — see Errors.

Examples

hanzo benchmark claims create

import { Configuration, BenchmarkApi } from 'hanzoai';

const api = new BenchmarkApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.postBenchmarkClaims({ data: [{"benchmark":"<benchmark>","model":"<model>","protocol":"<protocol>","provider":"<provider>"}], visibility: "<visibility>" });

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).post_benchmark_claims(data=[{"benchmark":"<benchmark>","model":"<model>","protocol":"<protocol>","provider":"<provider>"}], visibility="<visibility>")

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

resp, _, err := client.BenchmarkAPI.PostBenchmarkClaims(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::post_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).postBenchmarkClaims();

curl -X POST https://api.hanzo.ai/v1/benchmark/claims \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "data": [
         {
           "benchmark": "<benchmark>",
           "model": "<model>",
           "protocol": "<protocol>",
           "provider": "<provider>"
         }
       ],
       "visibility": "<visibility>"
     }'

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