# List node

URL: https://docs.hanzo.ai/docs/openapi/node/get-node

> Returns the caller org's currently connected bot nodes: what each one calls itself, the platform it runs on, its agent version, when its socket was established, and the capabilities and commands it reported.

`GET /v1/node`

> [Node →](https://docs.hanzo.ai/docs/openapi/node) · [All API references →](https://docs.hanzo.ai/docs/openapi) · [Get started →](https://docs.hanzo.ai/docs/guides)

|               |                                        |
| ------------- | -------------------------------------- |
| **Address**   | `https://api.hanzo.ai/v1/node`         |
| **Method**    | `GET`                                  |
| **Operation** | `get_node`                             |
| **Auth**      | `Authorization: Bearer $HANZO_API_KEY` |

Returns the caller org's currently connected bot nodes: what each one
calls itself, the platform it runs on, its agent version, when its socket was
established, and the capabilities and commands it reported.

Only this org's nodes are listed — the org is half of every key in the table it
reads — and only nodes attached to THIS replica, because the list is of live
sockets rather than of registrations. The capability and command lists are the
node's own self-report: useful to show, never load-bearing, because what a node
may actually be asked to do is decided at the socket against the deployment's
allowlist.

## Request

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

## Response

| Status    | Body            | Meaning |
| --------- | --------------- | ------- |
| `200`     | node.nodesView  | ok      |
| `default` | problem-details | refused |

`200` body — 8 fields.

| Field                 | In   | Type             | Always | Description                                                                                           |
| --------------------- | ---- | ---------------- | ------ | ----------------------------------------------------------------------------------------------------- |
| `nodes`               | body | node.nodeView\[] | —      | Nodes is every node of the caller's org with a live socket to THIS replica, ordered by id.            |
| `nodes[].caps`        | body | string\[]        | —      | Caps is the capability list the node reported.                                                        |
| `nodes[].commands`    | body | string\[]        | —      | Commands is the command list the node reported.                                                       |
| `nodes[].connectedAt` | body | string           | —      | ConnectedAt is when this node's socket was established, RFC3339 UTC.                                  |
| `nodes[].displayName` | body | string           | —      | DisplayName is the human name the node reported for itself.                                           |
| `nodes[].id`          | body | string           | —      | ID is the node's own identifier within the org — the value POST /v1/node/{id}/invoke addresses it by. |
| `nodes[].platform`    | body | string           | —      | Platform is the operating system and architecture the node reported.                                  |
| `nodes[].version`     | body | string           | —      | Version is the node agent's own version string.                                                       |

Failure carries the platform error shape — see [Errors](https://docs.hanzo.ai/docs/errors).

## Examples

**CLI**

```bash
hanzo node list
```

**SDK**

**.ts**

```ts
import { Configuration, NodeApi } from 'hanzoai';

const api = new NodeApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.getNode();
```

**.py**

```python
from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import NodeApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = NodeApi(client).get_node()
```

**.go**

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

resp, _, err := client.NodeAPI.GetNode(context.Background()).Execute()
if err != nil {
	return err
}
```

**.rs**

```rust
use hanzo_client::apis::{configuration::Configuration, node_api};

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

let result = node_api::get_node(&cfg, Default::default()).await?;
```

**.java**

```java
import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.NodeApi;

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

var result = new NodeApi(client).getNode();
```

**HTTP**

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

**MCP**

MCP reaches **node** through the `node` tool, which names its 1 operations with its own verbs — this one among them, under a name only MCP declares. `describe` explains any of them:

```bash
curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "describe",
         "arguments": {
           "op": "list_nodes"
         }
       }
     }'
```

---

[Node API](https://docs.hanzo.ai/docs/openapi/node) · [All Hanzo APIs](https://docs.hanzo.ai/docs/openapi) · [Interactive reference](https://docs.hanzo.ai/docs/openapi/reference)