List jobs

Answers the org's jobs, newest first, narrowed by ?status=.

GET /v1/train/jobs

Train → · All API references → · Get started →

Address	`https://api.hanzo.ai/v1/train/jobs`
Method	`GET`
Operation	`get_train_jobs`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Answers the org's jobs, newest first, narrowed by ?status=.

Request

2 fields.

Field	In	Type	Required	Description
`status`	query	string	—	Status narrows to one status.
`limit`	query	integer	—	Limit bounds the answer; default 50, at most 500.

Response

Status	Body	Meaning
`200`	train.jobsOut	ok
`default`	problem-details	refused

200 body — 79 fields.

Field	In	Type	Always	Description
`data`	body	train.Job[]	—	Data is the org's jobs, newest first.
`data[].adaptation`	body	train.Adaptation	—
`data[].adaptation.alpha`	body	number (double)	—	Alpha is an adapter's scale.
`data[].adaptation.basis`	body	string	—	Basis is a basis artifact, by sha256 or `basis://<base>/<name>`.
`data[].adaptation.chose`	body	train.Chose	—
`data[].adaptation.chose.mode`	body	string	—	Mode is the mode the job runs.
`data[].adaptation.chose.why`	body	string	—	Why says what decided it.
`data[].adaptation.mode`	body	string	—	Mode is full, readout (the head alone, over the frozen base), lora, qlora, basis or auto.
`data[].adaptation.rank`	body	integer (int64)	—	Rank is an adapter's rank, or how many of a basis's directions are used.
`data[].adaptation.residual_rank`	body	integer (int64)	—	ResidualRank is the rank of an orthonormal residual learned beside a basis's coefficients; 0 trains the coefficients alone.
`data[].adaptation.sources`	body	string[]	—	Sources are lora artifacts (sha256) a basis is built from, in place of Basis.
`data[].adaptation.targets`	body	string[]	—	Targets are the modules an adapter or a basis attaches to.
`data[].artifacts`	body	train.artifact[]	—	Artifacts are its outputs.
`data[].artifacts[].created`	body	integer (int64)	—	Created is when it was registered, unix seconds.
`data[].artifacts[].job`	body	string	—	Job is the job that produced it; empty for an upload.
`data[].artifacts[].kind`	body	string	—	Kind is checkpoint, lora, capability, basis or merged, or dataset for an upload.
`data[].artifacts[].meta`	body	any	—	Meta describes it: its base and revision, its modules, a basis's address.
`data[].artifacts[].name`	body	string	—	Name labels it.
`data[].artifacts[].sha256`	body	string	—	SHA256 is the hex digest of its bytes, and its name in the object store.
`data[].artifacts[].size`	body	integer (int64)	—	Size is its byte count.
`data[].artifacts[].state`	body	string	—	State is pending until its bytes are read back, then stored; deleted once the org deleted it or it outlived its retention unpublished.
`data[].base_model`	body	string	—
`data[].created`	body	integer (int64)	—	Created, Started and Ended are unix seconds; 0 is not yet.
`data[].created_by`	body	string	—	CreatedBy is the principal that created it.
`data[].dataset`	body	train.Dataset	—
`data[].dataset.splits`	body	object	—	Splits maps a role (train, validation) to the dataset's own split name.
`data[].dataset.splits.*`	body	string	—
`data[].dataset.uri`	body	string	—	URI names the data.
`data[].ended`	body	integer (int64)	—
`data[].error`	body	string	—	Error says why a job failed or stopped.
`data[].evaluation`	body	train.Evaluation	—
`data[].evaluation.suites`	body	string[]	—	Suites are the suites the job is meant to improve.
`data[].from`	body	string	—
`data[].id`	body	string	—	ID names the job.
`data[].objective`	body	train.Objective	—
`data[].objective.loss`	body	string	—	Loss is `cross_entropy`.
`data[].objective.terms`	body	train.Term[]	—	Terms are added to each row's loss.
`data[].objective.terms[].kind`	body	string	—	Kind names the term.
`data[].objective.terms[].margin`	body	number (double)	—	Margin is a hinge's margin, in logits.
`data[].objective.terms[].weight`	body	number (double)	—	Weight scales it; 0 is off.
`data[].output`	body	train.Output	—
`data[].output.kind`	body	string	—	Kind is checkpoint, lora, capability, basis or merged.
`data[].output.name`	body	string	—	Name labels it.
`data[].project`	body	string	—	Project is the creator's project scope.
`data[].protect`	body	train.Protect	—
`data[].protect.budget`	body	train.Budget	—
`data[].protect.budget.accuracy`	body	number (double)	—	Accuracy is the largest accuracy drop allowed.
`data[].protect.budget.ece`	body	number (double)	—	ECE is the largest calibration-error rise allowed.
`data[].protect.capabilities`	body	string[]	—	Capabilities are capability artifacts, by sha256.
`data[].protect.distillation`	body	boolean	—	Distillation adds KL to the base's answers on a preservation set drawn from the suites.
`data[].protect.projection`	body	train.Projection	—
`data[].protect.projection.strength`	body	number (double)	—	Strength is λ in [0, 1]; absent is 1, the whole of P g removed.
`data[].protect.suites`	body	string[]	—	Suites are capabilities the base already has, by suite.
`data[].published`	body	any	—	Published is the publish record, once published.
`data[].resources`	body	train.Resources	—
`data[].resources.budget`	body	integer (int64)	—	Budget bounds what the job's compute costs, in US cents; 0 is none beyond the payer's balance.
`data[].resources.devices`	body	string[]	—	Devices are the accelerator kinds the job may run on — cuda, rocm, metal, vulkan, cpu; none named is any its base runs.
`data[].resources.machines`	body	string[]	—	Machines are the org's linked machines by name; the first leads.
`data[].resources.max_seconds`	body	integer (int64)	—	MaxSeconds bounds the device-seconds the job's tasks use together; 0 is none.
`data[].resources.steps`	body	integer (int64)	—	Steps bounds optimizer steps; 0 runs the plan.
`data[].result`	body	any	—	Result is the lead's evaluation and verdict, once reported.
`data[].revision`	body	string	—
`data[].started`	body	integer (int64)	—
`data[].status`	body	string	—	Status is queued, running, evaluating, succeeded, rejected, failed, cancelled or stopped.
`data[].tasks`	body	train.TaskView[]	—	Tasks are its units of execution.
`data[].tasks[].device`	body	string	—	Device is the accelerator class it runs on — gpu or cpu — and Devices how many.
`data[].tasks[].devices`	body	integer (int64)	—
`data[].tasks[].held`	body	integer (int64)	—
`data[].tasks[].host`	body	string	—	Host is the machine that claimed it.
`data[].tasks[].id`	body	string	—	ID names the task.
`data[].tasks[].machine`	body	string	—	Machine is the machine it was placed on, or empty for any.
`data[].tasks[].role`	body	string	—	Role is lead or join.
`data[].tasks[].seconds`	body	integer (int64)	—	Seconds are the device-seconds its reports metered, and Held those held for it.
`data[].tasks[].seen`	body	integer (int64)	—	Seen is its last report, unix seconds.
`data[].tasks[].status`	body	string	—	Status is open, claimed, done or lost.
`data[].usage`	body	train.Usage	—
`data[].usage.cost_micro_usd`	body	integer (int64)	—	CostMicroUSD is what Seconds were charged, in micro-USD: 0 on the org's own machines.
`data[].usage.held`	body	integer (int64)	—	Held are the device-seconds held beyond Seconds; 0 once it ended.
`data[].usage.seconds`	body	integer (int64)	—	Seconds are the device-seconds used.

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo has no subcommand for this operation — the CLI serves only what cloud's live route table confirms. Use HTTP or an SDK.

.ts

.py

.go

.rs

.java

import { Configuration, TrainApi } from 'hanzoai';

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

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

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = TrainApi(client).get_train_jobs()

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

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

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

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

let result = train_api::get_train_jobs(&cfg, Default::default()).await?;

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

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

var result = new TrainApi(client).getTrainJobs();

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

MCP declares no tool for train — tools/list on https://api.hanzo.ai/v1/mcp names the products it does reach. Use HTTP or an SDK.

Train API · All Hanzo APIs · Interactive reference

Was this page useful?

PreviousGet jobs NextList models