> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/local-ai/nvpair/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/local-ai/nvpair/_mcp/server.

# Get node info

GET http%3A%2F%2F127.0.0.1%3A11434/v1/node-info

Returns telemetry for a discovered PAIR node. The desktop application polls this endpoint because the data is not fully represented in the broker control surface. The stable host UUID, not the display hostname, correlates discovery, membership, workloads, telemetry, and routing.


Reference: https://docs.nvidia.com/local-ai/nvpair/pair-api/node-info/get-node-info

## Response

### 200

Node telemetry snapshot.

- `uuid` (string, required) — Stable host UUID used to correlate discovery and routing.
- `hostname` (string, required)
- `trust` (enum, required)
  - Allowed values: `trusted`, `unpaired`, `pending`, `unknown`
- `cluster` (ClusterState, required)
- `addresses` (list of string, optional) — Reachable addresses advertised by the node.
- `servicePorts` (map from string to integer, optional) — Service ports keyed by service name.
- `engines` (list of enum, optional)
  - Allowed values: `ollama`, `lmstudio`
- `models` (list of NodeModel, optional) — Models reported as available on the node, where reported.

## Types

### ClusterState

- `member` (boolean, required)
- `clusterId` (string, optional, nullable)

### NodeModel

- `name` (string, required)
- `engine` (enum, required)
  - Allowed values: `ollama`, `lmstudio`

## Examples

**Response**

```json
{
  "uuid": "7c9e6679-7425-40de-944b-e07fc1f90ae7",
  "hostname": "workstation-01",
  "trust": "trusted",
  "cluster": {
    "member": true,
    "clusterId": "cluster_01J0D5TCGS8JQ2N8TZFRA0VN08"
  },
  "addresses": [
    "192.168.1.24",
    "fe80::1c2d:3e4f:5a6b:7c8d"
  ],
  "servicePorts": {
    "broker": 51101,
    "proxy": 51100,
    "scanner": 51102
  },
  "engines": [
    "ollama"
  ],
  "models": [
    {
      "name": "llama3.1",
      "engine": "ollama"
    }
  ]
}
```

**SDK Code**

```python default
import requests

url = "https://api.example.com/v1/node-info"

response = requests.get(url)

print(response.json())
```

```javascript default
const url = 'https://api.example.com/v1/node-info';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go default
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.example.com/v1/node-info"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby default
require 'uri'
require 'net/http'

url = URI("https://api.example.com/v1/node-info")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
```

```java default
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.example.com/v1/node-info")
  .asString();
```

```php default
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.example.com/v1/node-info');

echo $response->getBody();
```

```csharp default
using RestSharp;

var client = new RestClient("https://api.example.com/v1/node-info");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
```

```swift default
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.example.com/v1/node-info")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```