# List samples URL: https://docs.hanzo.ai/docs/openapi/compute/listfleetsamples > Returns the caller org's utilization series, oldest first. `GET /v1/compute/fleet/samples` > [Compute →](https://docs.hanzo.ai/docs/openapi/compute) · [All API references →](https://docs.hanzo.ai/docs/openapi) · [Get started →](https://docs.hanzo.ai/docs/guides) | | | | ------------- | ----------------------------------------------- | | **Address** | `https://api.hanzo.ai/v1/compute/fleet/samples` | | **Method** | `GET` | | **Operation** | `listFleetSamples` | | **Auth** | `Authorization: Bearer $HANZO_API_KEY` | Returns the caller org's utilization series, oldest first. A rejected narrower is a 400 carrying its own reason (the vocabulary is ours and safe to echo); a warehouse failure is logged and answered 503 "unavailable", because a chart that silently reads "no load" when the truth is "we cannot tell" is worse than one that says so. An ABSENT warehouse is different again: it returns an empty series, which renders honestly as "no samples yet". ## Request 3 fields. | Field | In | Type | Required | Description | | -------- | ----- | ------ | -------- | ----------------------------------------------------------------------------------------- | | `unit` | query | string | — | Unit selects one compute unit's series by its source-local id. | | `source` | query | string | — | Source selects one plane: "agent", "byo" or "visor". | | `range` | query | string | — | Range is the lookback window (e.g. "1h", "24h", "7d"); empty takes the warehouse default. | ## Response | Status | Body | Meaning | | --------- | ------------------ | ------- | | `200` | compute.sampleList | ok | | `default` | problem-details | refused | `200` body — 37 fields. | Field | In | Type | Always | Description | | ------------------------- | ---- | --------------------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------- | | `samples` | body | compute.sampleView\[] | — | Samples are the readings, OLDEST first — the order a chart plots. | | `samples[].at` | body | string | — | At is when the reading was MEASURED, RFC 3339 in UTC — the x-axis a chart plots against. | | `samples[].costCents` | body | integer (int64) | — | CostCents is what this unit resold for over the hour the reading falls in, in whole US cents. | | `samples[].cpuTemp` | body | number (double) | — | CPUTemp is the CPU package temperature in °C. | | `samples[].cpuUtil` | body | number (double) | — | CPUUtil is the busy fraction of all cores over the sample window, 0..1. | | `samples[].cpus` | body | integer (int64) | — | CPUs is logical cores. | | `samples[].decode` | body | number (double) | — | Decode is generation throughput over the sample window, in tokens per second. | | `samples[].diskRead` | body | number (double) | — | DiskRead is the block-device read rate in bytes per second. | | `samples[].diskTotal` | body | integer (int64) | — | DiskTotal is the size of those filesystems, in BYTES. | | `samples[].diskUsed` | body | integer (int64) | — | DiskUsed is the space used across local block filesystems, in BYTES. | | `samples[].diskWrite` | body | number (double) | — | DiskWrite is the block-device write rate in bytes per second. | | `samples[].gpuMemTotal` | body | integer (int64) | — | GPUMemTotal is dedicated VRAM in BYTES; absent when the GPU shares system memory (unified). | | `samples[].gpuMemUsed` | body | integer (int64) | — | GPUMemUsed is the memory held by GPU processes, in BYTES. | | `samples[].gpuModel` | body | string | — | GPUModel names the representative accelerator ("GB10"); GPUs carries how many. | | `samples[].gpuPower` | body | number (double) | — | GPUPower is the total GPU power draw in watts. | | `samples[].gpuPowerLimit` | body | number (double) | — | GPUPowerLimit is the total enforced GPU power limit in watts; absent when the driver reports none. | | `samples[].gpuTemp` | body | number (double) | — | GPUTemp is the hottest GPU's temperature in °C. | | `samples[].gpuUtil` | body | number (double) | — | GPUUtil is aggregate accelerator utilization as a FRACTION of 1 — 0.42 is 42% busy. | | `samples[].gpus` | body | integer (int64) | — | GPUs is how many accelerators the reading covers. | | `samples[].host` | body | string | — | Host is the hostname the unit reported at the time of the reading. | | `samples[].kind` | body | string | — | Kind is what the measured unit is: laptop, cloud, gpu, cluster, machine or worker. | | `samples[].kvCache` | body | number (double) | — | KVCache is the KV-cache occupancy, 0..1. | | `samples[].load1` | body | number (double) | — | Load1 is the 1-minute load average — runnable processes, not a percentage. | | `samples[].load5` | body | number (double) | — | Load5 is the 5-minute load average, the same units as Load1. | | `samples[].load15` | body | number (double) | — | Load15 is the 15-minute load average, the same units as Load1. | | `samples[].memFree` | body | integer (int64) | — | MemFree is host memory available, in BYTES, as reported rather than derived. | | `samples[].memUsed` | body | integer (int64) | — | MemUsed is host memory in use, in BYTES. | | `samples[].memory` | body | integer (int64) | — | Memory is total system RAM in BYTES at the time of the reading. | | `samples[].model` | body | string | — | Model is the model id(s) served on the unit, comma-separated, at most 128 bytes. | | `samples[].netRx` | body | number (double) | — | NetRx is the receive rate of physical interfaces in bytes per second. | | `samples[].netTx` | body | number (double) | — | NetTx is the transmit rate of physical interfaces in bytes per second. | | `samples[].prefill` | body | number (double) | — | Prefill is prompt (prefill) throughput over the sample window, in tokens per second. | | `samples[].running` | body | integer (int64) | — | Running is the number of requests being served at the reading. | | `samples[].source` | body | string | — | Source is the plane that reported the reading: "agent", "byo" or "visor" — the same vocabulary the board's rows carry, and what ?source= narrows on. | | `samples[].ttft` | body | number (double) | — | TTFT is the mean time to first token, in seconds, of requests that started in the window. | | `samples[].unit` | body | string | — | Unit is the source's own id for the measured unit. | | `samples[].waiting` | body | integer (int64) | — | Waiting is the number of requests queued at the reading. | Failure carries the platform error shape — see [Errors](https://docs.hanzo.ai/docs/errors). ## Examples **CLI** ```bash hanzo compute fleet samples get ``` **SDK** **.ts** ```ts import { Configuration, ComputeApi } from 'hanzoai'; const api = new ComputeApi(new Configuration({ accessToken: process.env.HANZO_API_KEY })); const { data } = await api.listFleetSamples(); ``` **.py** ```python from hanzoai.cloud import ApiClient, Configuration from hanzoai.cloud.api import ComputeApi client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"])) result = ComputeApi(client).list_fleet_samples() ``` **.go** ```go cfg := hanzoai.NewConfiguration() cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY")) client := hanzoai.NewAPIClient(cfg) resp, _, err := client.ComputeAPI.ListFleetSamples(context.Background()).Execute() if err != nil { return err } ``` **.rs** ```rust use hanzo_client::apis::{configuration::Configuration, compute_api}; let mut cfg = Configuration::new(); cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok(); let result = compute_api::list_fleet_samples(&cfg, Default::default()).await?; ``` **.java** ```java import ai.hanzo.cloud.ApiClient; import ai.hanzo.cloud.api.ComputeApi; ApiClient client = new ApiClient(); client.setBearerToken(System.getenv("HANZO_API_KEY")); var result = new ComputeApi(client).listFleetSamples(); ``` **HTTP** ```bash curl https://api.hanzo.ai/v1/compute/fleet/samples \ -H "Authorization: Bearer $HANZO_API_KEY" ``` **MCP** Tool `compute`, op `listFleetSamples` — POST the JSON-RPC envelope to `https://api.hanzo.ai/v1/mcp`. ```bash 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": "compute", "arguments": { "op": "listFleetSamples", "input": {} } } }' ``` --- [Compute API](https://docs.hanzo.ai/docs/openapi/compute) · [All Hanzo APIs](https://docs.hanzo.ai/docs/openapi) · [Interactive reference](https://docs.hanzo.ai/docs/openapi/reference)