List leaderboard

Answers one row per model for the benchmark named — what our own harness measured, beside what the vendor claims, and the gap between them.

GET /v1/benchmark/leaderboard

Benchmark → · All API references → · Get started →

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

Answers one row per model for the benchmark named — what our own harness measured, beside what the vendor claims, and the gap between them.

The gap is the point of the arena; provider-reported claims have run materially hot against one standardized harness.

The two planes are NEVER blended, and that is the rule to read the rows by: a model we have measured but no vendor has claimed for shows published null, a model with only a claim shows measured null, and gap exists only where both do.

Published, Claims, Spread and Mean read the platform's own public claims (org "admin") and nothing else, whoever asks. Other orgs' claims are at /v1/benchmark/claims, labelled, and never on this board.

n is coverage and is not decoration: two measured numbers taken over different item counts are not comparable, so read the row's n before reading its accuracy.

Request

1 field.

Field	In	Type	Required	Description
`benchmark`	query	string	—	Benchmark is the catalog id to read, defaulting to gpqa_diamond.

Response

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

200 body — 15 fields.

Field	In	Type	Always	Description
`benchmark`	body	string	—	Benchmark is the catalog id these rows are about.
`rows`	body	benchmark.LeaderRow[]	—	Rows is one per model, ordered by measured accuracy descending.
`rows[].ciHigh`	body	number (double)	—	CIHigh is the upper bound of that interval.
`rows[].ciLow`	body	number (double)	—	CILow and CIHigh are the 95% Wilson interval on Measured, in percent.
`rows[].claims`	body	integer (int64)	—	Claims is how many independent claims the platform holds for this model on this benchmark.
`rows[].gap`	body	number (double)	—	published − measured (the arena signal)
`rows[].mean`	body	number (double)	—	Mean is the unweighted average of every claim, which answers a different question from Published: what the field says on average, rather than what the vendor says about itself.
`rows[].measured`	body	number (double)	—	hanzo-measured accuracy % (nil if unrun)
`rows[].measuredAt`	body	string (date-time)	—	MeasuredAt is when the run behind Measured was recorded.
`rows[].model`	body	string	—	the model this row scores
`rows[].n`	body	integer (int64)	—	coverage — NEVER compare across different n
`rows[].protocol`	body	string	—	how the vendor scored their claim: single-attempt, pass@k or agentic
`rows[].published`	body	number (double)	—	the platform's selected claim % (nil if none)
`rows[].run`	body	string	—	Run names the measurement Measured came from, and MeasuredAt is when it ran.
`rows[].spread`	body	number (double)	—	Spread is the distance between the highest and lowest of them, nil when there is only one.

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo benchmark leaderboard

.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.getBenchmarkLeaderboard();

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_leaderboard()

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

resp, _, err := client.BenchmarkAPI.GetBenchmarkLeaderboard(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_leaderboard(&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).getBenchmarkLeaderboard();

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

Tool benchmark, op get_benchmark_leaderboard — 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": "benchmark",
         "arguments": {
           "op": "get_benchmark_leaderboard",
           "input": {}
         }
       }
     }'

Benchmark API · All Hanzo APIs · Interactive reference

Was this page useful?

PreviousList history NextList presets