List dataset

Lists this org's datasets, each with its newest version.

GET /v1/dataset

Dataset → · All API references → · Get started →

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

Lists this org's datasets, each with its newest version. An org that has declared none gets an empty list; a store that cannot be reached gets a refusal, never an empty list, because the two read identically and only one of them is true.

Request

GET /v1/dataset takes no parameters and no body — the credential is the whole request.

Response

Status	Body	Meaning
`200`	dataset.riskDatasetList	ok
`default`	problem-details	refused

200 body — 31 fields.

Field	In	Type	Always	Description
`items`	body	dataset.riskDataset[]	—	Items is one entry per dataset, carrying its newest version.
`items[].at`	body	string	—	At is when this version last changed state, RFC 3339 UTC.
`items[].by`	body	string	—	By is who moved it there: the validated user, or the org itself when the caller is a machine with no user behind it.
`items[].counts`	body	dataset.riskSplitCounts	—
`items[].counts.judged`	body	integer (int64)	—	Judged is how many rows carry a disposition.
`items[].counts.productive`	body	integer (int64)	—	Productive is how many judged rows carry the one disposition.
`items[].counts.rows`	body	integer (int64)	—	Rows is how many rows the version holds across every split.
`items[].counts.subjects`	body	integer (int64)	—	Subjects is how many distinct subjects the rows belong to.
`items[].counts.test`	body	integer (int64)	—	Test is how many fall after the second cut — the LATEST slice, and the only one a score is honest about, since the split is temporal.
`items[].counts.train`	body	integer (int64)	—	Train is how many rows fall before the first cut — the EARLIEST slice of the window, which is what a model is fitted on.
`items[].counts.unproductive`	body	integer (int64)	—	Unproductive is how many carry the other.
`items[].counts.val`	body	integer (int64)	—	Val is how many fall between the two cuts, held out for tuning.
`items[].digest`	body	string	—	Digest fingerprints the SPEC and the ROWS together.
`items[].name`	body	string	—	Name identifies the dataset across all of its versions.
`items[].oversize`	body	integer (int64)	—	Oversize is how many of the window's subjects this version could NOT carry because their subject identity exceeds the plane's per-subject byte bound.
`items[].refusal`	body	string	—	Refusal names why there are no bytes, when there are none.
`items[].running`	body	boolean	—	Running is true while THIS process is materialising the version.
`items[].share`	body	integer (int64)	—	Share is the fraction of the window's subjects admitted, in thousandths.
`items[].spec`	body	dataset.riskDatasetSpec	—
`items[].spec.cuts`	body	string[]	—	Cuts are the two RFC 3339 instants dividing train \| val \| test.
`items[].spec.dims`	body	string[]	—	Dims are the coordinates to carry, by published name.
`items[].spec.from`	body	string	—	From is where the event window opens, RFC 3339, INCLUSIVE.
`items[].spec.horizon`	body	integer (int64)	—	Horizon is how many days a row must have aged before it may be admitted.
`items[].spec.kind`	body	string	—	Kind narrows to one subject kind — person, session or account.
`items[].spec.name`	body	string	—	Name identifies the dataset across its versions: lower-case letters, digits and hyphens, starting with a letter.
`items[].spec.rows`	body	integer (int64)	—	Rows caps the materialisation.
`items[].spec.seed`	body	string	—	Seed decides WHICH subjects are admitted when the window holds more rows than the cap allows.
`items[].spec.to`	body	string	—	To is where the window ends, EXCLUSIVE, so two datasets meeting at one instant share no row.
`items[].status`	body	string	—	Status is declared, materializing, ready or refused.
`items[].truncated`	body	boolean	—	Truncated is true when the row cap bound before the window ran out.
`items[].version`	body	integer (int64)	—	Version is which version this is, from 1 and monotone within the dataset.

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo dataset list

.ts

.py

.go

.rs

.java

import { Configuration, DatasetApi } from 'hanzoai';

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

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

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = DatasetApi(client).risk_datasets()

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

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

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

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

let result = dataset_api::risk_datasets(&cfg, Default::default()).await?;

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

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

var result = new DatasetApi(client).riskDatasets();

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

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

Dataset API · All Hanzo APIs · Interactive reference

Was this page useful?

PreviousList lineage NextDelete dataset