Get dataset

Describes every version of one dataset, newest first — the whole history, because the point of a version is that the older ones are still there and a model fitted last quarter cites one of them.

GET /v1/dataset/{name}

Dataset → · All API references → · Get started →

Address	`https://api.hanzo.ai/v1/dataset/{name}`
Method	`GET`
Operation	`riskDataset`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Describes every version of one dataset, newest first — the whole history, because the point of a version is that the older ones are still there and a model fitted last quarter cites one of them.

A name this org does not own answers 404, exactly as an unknown name does, so a probe learns nothing about another tenant's datasets.

Request

1 field.

Field	In	Type	Required	Description
`name`	path	string	yes	Name is the dataset, from the path.

Response

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

200 body — 32 fields.

Field	In	Type	Always	Description
`items`	body	dataset.riskDataset[]	—	Items is every version of it, newest first — including the disposed ones, whose record outlives their rows.
`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.
`name`	body	string	—	Name is the dataset these versions belong to, as the register holds it.

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo dataset get <name>

.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.riskDataset({ name: 'name' });

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_dataset(name='name')

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

resp, _, err := client.DatasetAPI.RiskDataset(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_dataset(&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).riskDataset();

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

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

Dataset API · All Hanzo APIs · Interactive reference

Was this page useful?

PreviousCreate dataset NextList lineage