policies and you get one run back per policy, all training in parallel on their own GPUs so you can compare them.
Create a run
Request body
The dataset to train on: a Hugging Face LeRobot repo id such as
lerobot/pusht, or a gs:// path to a LeRobot dataset.Policy types to train, one run each. Between
1 and 8 entries. Fetch the list from GET /v1/training_policies.The GPU to train on. Defaults to
gpu_t4. Each policy declares a minimum tier — see GET /v1/hardware_tiers.Maps your dataset’s camera keys to the policy’s image slots: each key is a camera key from your dataset, each value the slot to feed it into. Omit it and Kite maps them for you. See Inspect a dataset for your dataset’s camera keys and a worked example.
Push the trained policy to your connected Hugging Face account when the run finishes. Defaults to
false.Opaque data echoed back on the run and on its webhook events. Use it to tie a run to your own job id.
Response — 202 Accepted
group_id, so you can tell which ones were launched together even if their webhooks arrive out of order.
Common failures at create time:
400 policy_not_available— an unknown policy, or one that can’t currently be trained400 hardware_tier_too_small— the tier is below the policy’s minimum;details.min_hardware_tiertells you what it needs400 hardware_tier_not_available— an unknown or currently disabled tier;details.available_tierslists the usable ones402 insufficient_tokens— not enough credits for the whole request429 concurrency_limit_exceeded— you already have the maximum number of runs in flight429 capacity_exceeded— Kite is at GPU capacity; retry shortly503 service_unavailable— cloud GPU training is temporarily down
Idempotency
Pass a uniqueIdempotency-Key header to make retries safe. A repeated request with the same key returns the original runs instead of starting duplicates — so a dropped connection or a CI retry never double-charges you.
Reusing a key with a different payload returns
409 Conflict — the key is bound to the first request body it saw.Track progress
Poll the run to watch it move through its lifecycle.progress and metrics come straight from the running trainer.
status field moves through:
phase tells you what a processing run is doing right now — useful, because provisioning a GPU and training on it both look the same from status alone:
You can also poll any run through the uniform operations view, which works the same for every Kite resource:
Read the logs
tail lines of the trainer’s output, capped at 1000. Logs stay readable after the run finishes, so this is where you look when a run fails.
Get your policy
Whenstatus is succeeded, output describes what the run produced.
Response — output
hf_push_status goes from pushing (attempt n/5) to ok. It can also end skipped: <reason>, for example skipped: no Hugging Face account connected, or failed: <reason>, for example failed: the connected Hugging Face account can't write to this repo.
Only the latest checkpoint is summarised inline — list them all at /checkpoints, and download any of them from its download_url.
Download a checkpoint
List every checkpoint a run saved, oldest first:pretrained_model/ directory:
-L in curl). Your client doesn’t send your API key on to that link, and the link doesn’t need it.
It unzips to a standard LeRobot checkpoint — the same files the dashboard gives you, and the same ones push_to_hub uploads.
Checkpoints are paginated on step: pass the response’s next_cursor back as after, and stop when has_more is false. A run with a small save_freq can have thousands of them.
The result is a standard LeRobot policy checkpoint. It’s the same artifact the dashboard produces, so it loads anywhere LeRobot policies load. No proprietary output format, no lock-in.
Cancel a run
Stop a run at any time. Cancelling releases the GPU immediately.409 not_cancelable.
Discover policies and GPUs
Rather than hard-coding names, fetch what’s currently trainable. Both lists are small and never paginate.min_hardware_tier, min_vram_gb, and recommended default_steps and default_batch_size. A policy with "available": false can’t be trained right now.
tokens_per_hour rate. A tier with "available": false exists but is switched off.
Inspect a dataset
Check a dataset is trainable — and get its camera keys — before spending any credits.camera_keys is what cameras.rename maps from. To feed those two cameras into a policy’s top and wrist slots:
400 dataset_not_readable.
What a run costs
A run is charged the minutes its GPU runs, at its tier’s rate. When its GPU job starts, it holds one GPU-hour from your balance. When it ends, it is charged its minutes against that hold: what the hold covered beyond them comes back, and minutes beyond it are taken then. A request that starts several runs is charged for each of them. A run that fails, or whose GPU never starts, is not charged at all. Ask the API what runs will cost before you create them:tokens is what those runs are charged if each trains for hours. tokens_held is what creating them holds, and so what your balance must cover.
Runs started through the API bill from the same credit balance as the dashboard, and appear in GET /v1/usage under training.
The training run object
GET /v1/training_runs/:id reads the run’s live state. List, create, and cancel responses return the stored record: there, phase, status_message, and eval are null and output.checkpoint_count is 0. Retrieve the run for its progress.List your runs
next_cursor as after to fetch the next page.
Runs you start through the API also appear in the Training section of the dashboard, alongside the ones you start there. It’s one set of runs on one set of GPUs, whichever way you launch them.