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

# Get detailed node information

GET /v1/nodes/{nodeUUID}

Get detailed information about a specific node including resources, system info, and health status

Reference: https://docs.nvidia.com/fleet-intel/fleet-intel/api-explorer/nodes/get-v-1-nodes-node-uuid

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: fleet-intelligence
  version: 1.0.0
paths:
  /v1/nodes/{nodeUUID}:
    get:
      operationId: getV1NodesNodeUuid
      summary: Get detailed node information
      description: >-
        Get detailed information about a specific node including resources,
        system info, and health status
      tags:
        - nodes
      parameters:
        - name: nodeUUID
          in: path
          description: Node UUID
          required: true
          schema:
            type: string
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/models.NodeDetailsResponse'
        '400':
          description: Bad Request
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/models.ErrorResponse'
        '401':
          description: Unauthorized
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/models.ErrorResponse'
        '403':
          description: Forbidden - UAM authorization denied
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/models.ErrorResponse'
        '404':
          description: Not Found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/models.ErrorResponse'
        '499':
          description: Client Closed Request - request was canceled by the client
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/models.ErrorResponse'
        '500':
          description: Internal Server Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/models.ErrorResponse'
        '503':
          description: Service Unavailable
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/models.ErrorResponse'
components:
  schemas:
    models.AgentStatus:
      type: string
      enum:
        - Online
        - Offline
        - Unknown
      title: models.AgentStatus
    models.FirmwareCheck:
      type: string
      enum:
        - Passed
        - Failed
        - Unknown
      title: models.FirmwareCheck
    models.GeoLocation:
      type: object
      properties:
        city:
          type: string
        country:
          type: string
        latitude:
          type: number
          format: double
        longitude:
          type: number
          format: double
        region:
          type: string
      title: models.GeoLocation
    models.GPUFirmwareVersion:
      type: object
      properties:
        firmwareVersion:
          type: string
        gpuIndex:
          type: string
      title: models.GPUFirmwareVersion
    models.HealthState:
      type: string
      enum:
        - Healthy
        - Degraded
        - Unhealthy
        - Unknown
        - Unsupported
        - Pending
      title: models.HealthState
    models.IntegrityCheck:
      type: string
      enum:
        - Verified
        - Unverified
        - Degraded
        - Pending
        - Unsupported
        - Unknown
      title: models.IntegrityCheck
    models.NRASErrorDetail:
      type: object
      properties:
        code:
          type: integer
        description:
          type: string
        fieldName:
          type: string
        httpStatus:
          type: string
        message:
          type: string
      title: models.NRASErrorDetail
    models.CertChainStatus:
      type: object
      properties:
        x-nvidia-cert-expiration-date:
          type: string
        x-nvidia-cert-ocsp-nonce-matches:
          type: boolean
        x-nvidia-cert-ocsp-response-valid:
          type: boolean
        x-nvidia-cert-ocsp-status:
          type: string
        x-nvidia-cert-revocation-reason:
          type: string
        x-nvidia-cert-status:
          type: string
      title: models.CertChainStatus
    models.JWTClaims:
      type: object
      properties:
        eat_nonce:
          type: string
        exp:
          type: integer
        hwmodel:
          type: string
          description: Hardware info
        iat:
          type: integer
        iss:
          type: string
          description: Standard JWT claims
        jti:
          type: string
        measres:
          type: string
        nbf:
          type: integer
        sub:
          type: string
        ueid:
          type: string
        x-nvidia-attestation-warning:
          type: string
        x-nvidia-error-details:
          type: array
          items:
            $ref: '#/components/schemas/models.NRASErrorDetail'
        x-nvidia-gpu-arch-check:
          type: boolean
          description: NVIDIA attestation claims - GPU specific
        x-nvidia-gpu-attestation-report-cert-chain:
          $ref: '#/components/schemas/models.CertChainStatus'
        x-nvidia-gpu-attestation-report-nonce-match:
          type: boolean
        x-nvidia-gpu-attestation-report-parsed:
          type: boolean
        x-nvidia-gpu-attestation-report-signature-verified:
          type: boolean
        x-nvidia-gpu-vbios-rim-fetched:
          type: boolean
        x-nvidia-gpu-vbios-rim-measurements-available:
          type: boolean
        x-nvidia-gpu-vbios-version:
          type: string
        x-nvidia-mismatch-measurement-records:
          type: array
          items:
            description: Any type
        x-nvidia-overall-att-result:
          type: boolean
          description: NVIDIA attestation claims - overall result (for overall JWT)
      title: models.JWTClaims
    models.IntegrityCheckExtraInfo:
      type: object
      properties:
        errorDetails:
          type: string
        gpuEvidencePresent:
          type: boolean
        gpuResults:
          type: object
          additionalProperties:
            $ref: '#/components/schemas/models.JWTClaims'
        nrasCallResult:
          type: string
        overallAttestationResult:
          type: boolean
      title: models.IntegrityCheckExtraInfo
    models.CPUInfo:
      type: object
      properties:
        architecture:
          type: string
        logicalCores:
          type: string
        manufacturer:
          type: string
        type:
          type: string
      title: models.CPUInfo
    models.BlockDevice:
      type: object
      properties:
        fsType:
          type: string
        mountPoint:
          type: string
          description: |-
            Vendor     string   `json:"vendor" example:"Samsung"`
            Model      string   `json:"model" example:"SSD 870 EVO"`
            Rev        string   `json:"rev" example:"1B6Q"`
        name:
          type: string
        parents:
          type: array
          items:
            type: string
        partUUID:
          type: string
        size:
          type: integer
        type:
          type: string
        used:
          type: integer
        wwn:
          type: string
          description: |-
            Rota       bool     `json:"rota" example:"true"`
            Serial     string   `json:"serial" example:"ABC123"`
      title: models.BlockDevice
    models.DiskInfo:
      type: object
      properties:
        blockDevices:
          type: array
          items:
            $ref: '#/components/schemas/models.BlockDevice'
        containerRootDisk:
          type: string
      title: models.DiskInfo
    models.GPUDevice:
      type: object
      properties:
        boardID:
          type: integer
        busID:
          type: string
        chassisSN:
          type: string
        gpuIndex:
          type: string
        minorID:
          type: string
        sn:
          type: string
        uuid:
          type: string
        vbiosVersion:
          type: string
      title: models.GPUDevice
    models.GPUInfo:
      type: object
      properties:
        architecture:
          type: string
        gpus:
          type: array
          items:
            $ref: '#/components/schemas/models.GPUDevice'
        manufacturer:
          type: string
        memory:
          type: string
        product:
          type: string
      title: models.GPUInfo
    models.MemoryInfo:
      type: object
      properties:
        totalBytes:
          type: string
      title: models.MemoryInfo
    models.NicInterface:
      type: object
      properties:
        interface:
          type: string
        ip:
          type: string
        mac:
          type: string
      title: models.NicInterface
    models.NicInfo:
      type: object
      properties:
        privateIPInterfaces:
          type: array
          items:
            $ref: '#/components/schemas/models.NicInterface'
      title: models.NicInfo
    models.NodeResources:
      type: object
      properties:
        cpuInfo:
          $ref: '#/components/schemas/models.CPUInfo'
        diskInfo:
          $ref: '#/components/schemas/models.DiskInfo'
        gpuInfo:
          $ref: '#/components/schemas/models.GPUInfo'
        memoryInfo:
          $ref: '#/components/schemas/models.MemoryInfo'
        nicInfo:
          $ref: '#/components/schemas/models.NicInfo'
      title: models.NodeResources
    models.SystemInfo:
      type: object
      properties:
        agentVersion:
          type: string
        bootID:
          type: string
        containerRuntimeVersion:
          type: string
        cudaVersion:
          type: string
        dcgmVersion:
          type: string
        gpuDriverVersion:
          type: string
        hostname:
          type: string
        kernelVersion:
          type: string
        operatingSystem:
          type: string
        osImage:
          type: string
        startedAt:
          type: string
        systemUUID:
          type: string
      title: models.SystemInfo
    models.NodeDetailsResponse:
      type: object
      properties:
        agentStatus:
          $ref: '#/components/schemas/models.AgentStatus'
        agentVersion:
          type: string
        computeZone:
          type: string
        computeZoneId:
          type: string
        degradedComponentCount:
          type: integer
        enrolledAt:
          type: string
        firmwareCheck:
          $ref: '#/components/schemas/models.FirmwareCheck'
        geoLocation:
          $ref: '#/components/schemas/models.GeoLocation'
        gpuCount:
          type: integer
        gpuDriverVersion:
          type: string
        gpuFirmwareVersions:
          type: array
          items:
            $ref: '#/components/schemas/models.GPUFirmwareVersion'
        gpuType:
          type: string
        healthStatus:
          $ref: '#/components/schemas/models.HealthState'
        healthyComponentCount:
          type: integer
        hostname:
          type: string
        integrityCheck:
          $ref: '#/components/schemas/models.IntegrityCheck'
        integrityCheckExtraInfo:
          $ref: '#/components/schemas/models.IntegrityCheckExtraInfo'
        integrityCheckReason:
          type: string
        kernelVersion:
          type: string
        lastIntegrityCheckTS:
          type: string
        lastUpdatedTS:
          type: string
        nodeGroup:
          type: string
        nodeGroupId:
          type: string
        nodeUUID:
          type: string
        privateIP:
          type: string
        publicIP:
          type: string
        resources:
          $ref: '#/components/schemas/models.NodeResources'
        systemInfo:
          $ref: '#/components/schemas/models.SystemInfo'
        tags:
          type: array
          items:
            type: string
        unhealthyComponentCount:
          type: integer
      title: models.NodeDetailsResponse
    models.KASRequestStatus:
      type: object
      properties:
        requestId:
          type: string
          description: Request ID for tracing
        statusCode:
          type: string
          description: Status code from KAS
        statusDescription:
          type: string
          description: Status description from KAS
      description: >-
        RequestStatus contains KAS-specific error details

        This is added to reflect the field in OpenAPI docs for UI reference and
        not populated by our code

        If KAS returns an error, the request will not be forwarded to the
        backend
      title: models.KASRequestStatus
    models.ErrorResponse:
      type: object
      properties:
        details:
          type: string
          description: Detailed error information
        error:
          type: string
          description: Error message or type
        requestStatus:
          $ref: '#/components/schemas/models.KASRequestStatus'
      description: >-
        Standard error response returned by all API endpoints. For KAS API
        errors, requestStatus fields are populated.
      title: models.ErrorResponse

```

## Examples



**Response**

```json
{
  "agentStatus": "Online",
  "agentVersion": "1.2.3",
  "computeZone": "compute-zone-1",
  "computeZoneId": "550e8400-e29b-41d4-a716-446655440000",
  "degradedComponentCount": 1,
  "enrolledAt": "2025-08-11T17:23:02Z",
  "firmwareCheck": "Passed",
  "geoLocation": {
    "city": "Baltimore",
    "country": "United States",
    "latitude": 39.0458,
    "longitude": -76.6413,
    "region": "us-east-1"
  },
  "gpuCount": 4,
  "gpuDriverVersion": "550.120",
  "gpuFirmwareVersions": [
    {
      "firmwareVersion": "90.17.A9.00.0B",
      "gpuIndex": "0"
    }
  ],
  "gpuType": "NVIDIA-T400-4GB",
  "healthStatus": "Healthy",
  "healthyComponentCount": 3,
  "hostname": "node-001",
  "integrityCheck": "Verified",
  "integrityCheckExtraInfo": {
    "errorDetails": "SDK error: code=13, message=nonce refresh failed",
    "gpuEvidencePresent": true,
    "gpuResults": {},
    "nrasCallResult": "NRAS attestation failed: GPU-0: NONCE_NOT_MATCHING",
    "overallAttestationResult": false
  },
  "integrityCheckReason": "Attestation verification unavailable: SDK error",
  "kernelVersion": "6.8.0-49-generic",
  "lastIntegrityCheckTS": "2024-01-15T10:30:00Z",
  "lastUpdatedTS": "2024-01-15T10:30:00Z",
  "nodeGroup": "node-group-1",
  "nodeGroupId": "550e8400-e29b-41d4-a716-446655440001",
  "nodeUUID": "node-123",
  "privateIP": "10.0.0.100",
  "publicIP": "203.0.113.100",
  "resources": {
    "cpuInfo": {
      "architecture": "x86_64",
      "logicalCores": "16",
      "manufacturer": "Intel",
      "type": "x86_64"
    },
    "diskInfo": {
      "blockDevices": [
        {
          "fsType": "ext4",
          "mountPoint": "/",
          "name": "sda",
          "parents": [
            "string"
          ],
          "partUUID": "12345678-1234-1234-1234-123456789012",
          "size": 1000204886016,
          "type": "disk",
          "used": 500102443008,
          "wwn": "0x50014ee2"
        }
      ],
      "containerRootDisk": "/dev/sda1"
    },
    "gpuInfo": {
      "architecture": "Ada Lovelace",
      "gpus": [
        {
          "boardID": 0,
          "busID": "00000000:01:00.0",
          "chassisSN": "1583425610002",
          "gpuIndex": "0",
          "minorID": "0",
          "sn": "SN123456789",
          "uuid": "GPU-12345678-1234-1234-1234-123456789012",
          "vbiosVersion": "90.17.A9.00.0B"
        }
      ],
      "manufacturer": "NVIDIA",
      "memory": "24GB",
      "product": "NVIDIA GeForce RTX 4090"
    },
    "memoryInfo": {
      "totalBytes": "34359738368"
    },
    "nicInfo": {
      "privateIPInterfaces": [
        {
          "interface": "eth0",
          "ip": "192.168.1.100",
          "mac": "00:11:22:33:44:55"
        }
      ]
    }
  },
  "systemInfo": {
    "agentVersion": "1.2.3",
    "bootID": "01532617-6071-404f-9bd7-6e5871a00aa9",
    "containerRuntimeVersion": "containerd://1.7.25",
    "cudaVersion": "12.4",
    "dcgmVersion": "4.5.2",
    "gpuDriverVersion": "550.120",
    "hostname": "node-001",
    "kernelVersion": "6.8.0-49-generic",
    "operatingSystem": "linux",
    "osImage": "Ubuntu 22.04.5 LTS",
    "startedAt": "2025-08-11T17:23:02Z",
    "systemUUID": "4c4c4544-004a-3410-804c-c7c04f313434"
  },
  "tags": [
    "gpu",
    "high-memory"
  ],
  "unhealthyComponentCount": 1
}
```

**SDK Code**

```python
import requests

url = "https://api.example.com/v1/nodes/nodeUUID"

response = requests.get(url)

print(response.json())
```

```javascript
const url = 'https://api.example.com/v1/nodes/nodeUUID';
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
package main

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

func main() {

	url := "https://api.example.com/v1/nodes/nodeUUID"

	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
require 'uri'
require 'net/http'

url = URI("https://api.example.com/v1/nodes/nodeUUID")

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
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

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

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

$client = new \GuzzleHttp\Client();

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

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

```csharp
using RestSharp;

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

```swift
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.example.com/v1/nodes/nodeUUID")! 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()
```