> 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 error report

GET /v1/reports/error

Get error report grouped by error type or node in JSON or CSV format. Default response is JSON. For CSV download (list view only), set format=csv query parameter. Response structure varies based on view and groupBy parameters:
- When view=list and groupBy=error: The 'errors' field is populated with paginated list
- When view=list and groupBy=node: The 'nodes' field is populated with paginated list
- When view=graph and groupBy=error: Returns time-series data with optional step parameter (page and pageSize not used)
- When view=overview: Returns aggregate statistics (groupBy parameter not required, page and pageSize not used)

Reference: https://docs.nvidia.com/fleet-intel/fleet-intel/api-explorer/reports/get-v-1-reports-error

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: fleet-intelligence
  version: 1.0.0
paths:
  /v1/reports/error:
    get:
      operationId: getV1ReportsError
      summary: Get error report
      description: >-
        Get error report grouped by error type or node in JSON or CSV format.
        Default response is JSON. For CSV download (list view only), set
        format=csv query parameter. Response structure varies based on view and
        groupBy parameters:

        - When view=list and groupBy=error: The 'errors' field is populated with
        paginated list

        - When view=list and groupBy=node: The 'nodes' field is populated with
        paginated list

        - When view=graph and groupBy=error: Returns time-series data with
        optional step parameter (page and pageSize not used)

        - When view=overview: Returns aggregate statistics (groupBy parameter
        not required, page and pageSize not used)
      tags:
        - reports
      parameters:
        - name: groupBy
          in: query
          description: Group by error or node (not required for overview view)
          required: false
          schema:
            $ref: '#/components/schemas/V1ReportsErrorGetParametersGroupBy'
        - name: view
          in: query
          description: 'View type: list, graph, or overview'
          required: true
          schema:
            $ref: '#/components/schemas/V1ReportsErrorGetParametersView'
        - name: format
          in: query
          description: Response format (json or csv, only for list view)
          required: false
          schema:
            $ref: '#/components/schemas/V1ReportsErrorGetParametersFormat'
            default: json
        - name: page
          in: query
          description: Page number (Not used for CSV format, graph view, or overview view)
          required: false
          schema:
            type: integer
            default: 0
        - name: pageSize
          in: query
          description: Page size (Not used for CSV format, graph view, or overview view)
          required: false
          schema:
            type: integer
            default: 10
        - name: step
          in: query
          description: >-
            Query resolution step width in duration format (e.g. 1h, 1m). Only
            used for graph view. If not provided, backend will choose a suitable
            step width. Minimum step width is 1 minute.
          required: false
          schema:
            type: string
        - name: computeZoneIds
          in: query
          description: Filter by computezone IDs. Empty means all computezones
          required: false
          schema:
            type: array
            items:
              type: string
        - name: nodeGroupIds
          in: query
          description: Filter by nodegroup IDs. Empty means all nodegroups
          required: false
          schema:
            type: array
            items:
              type: string
        - name: tags
          in: query
          description: >-
            Filter by tags (AND logic - matches nodes with ANY of the specified
            tags). Empty means all nodes
          required: false
          schema:
            type: array
            items:
              type: string
        - name: errors
          in: query
          description: >-
            Filter nodes by specific error types (only for list view,
            groupBy=node). Returns ALL errors for nodes that have any of the
            specified errors. Examples: 'NVSwitch Fatal Error', 'xid_154'
          required: false
          schema:
            type: array
            items:
              type: string
        - name: timeMode
          in: query
          description: >-
            Time mode: 'absolute' (default) or 'relative'. Absolute requires
            start/end; relative requires window
          required: false
          schema:
            type: string
        - name: window
          in: query
          description: >-
            Relative time window (e.g., 1h, 1m, 30s). Only used when
            timeMode=relative
          required: false
          schema:
            type: string
        - name: startTime
          in: query
          description: >-
            Start time for filtering errors (RFC3339 format). Required when
            timeMode=absolute
          required: false
          schema:
            type: string
        - name: endTime
          in: query
          description: >-
            End time for filtering errors (RFC3339 format). Required when
            timeMode=absolute
          required: false
          schema:
            type: string
      responses:
        '200':
          description: Graph response grouped by error (view=graph, groupBy=error)
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/reports_getV1ReportsError_Response_200'
        '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'
        '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:
    V1ReportsErrorGetParametersGroupBy:
      type: string
      enum:
        - error
        - node
      title: V1ReportsErrorGetParametersGroupBy
    V1ReportsErrorGetParametersView:
      type: string
      enum:
        - list
        - graph
        - overview
      title: V1ReportsErrorGetParametersView
    V1ReportsErrorGetParametersFormat:
      type: string
      enum:
        - json
        - csv
      default: json
      title: V1ReportsErrorGetParametersFormat
    models.ActionPersona:
      type: string
      enum:
        - tenant
        - dc_admin
      description: Target persona (stored in DB, stripped before API response)
      title: models.ActionPersona
    models.ActionType:
      type: string
      enum:
        - immediate
        - investigatory
      description: 'Action type: "immediate" or "investigatory"'
      title: models.ActionType
    models.SuggestedAction:
      type: object
      properties:
        action:
          type: string
          description: Resolution action from Guidance Classes sheet
        code:
          type: string
          description: Action code from NVIDIA XID catalog
        persona:
          $ref: '#/components/schemas/models.ActionPersona'
        type:
          $ref: '#/components/schemas/models.ActionType'
      title: models.SuggestedAction
    models.ByError:
      type: object
      properties:
        count:
          type: integer
        name:
          type: string
        nodeCount:
          type: integer
        suggestedAction:
          $ref: '#/components/schemas/models.SuggestedAction'
      title: models.ByError
    models.ByErrorResponse:
      type: object
      properties:
        errors:
          type: array
          items:
            $ref: '#/components/schemas/models.ByError'
        hasMore:
          type: boolean
        page:
          type: integer
        pageSize:
          type: integer
        total:
          type: integer
      title: models.ByErrorResponse
    models.ByNode:
      type: object
      properties:
        errors:
          type: array
          items:
            type: string
        hostname:
          type: string
        nodeUUID:
          type: string
      title: models.ByNode
    models.ByNodeResponse:
      type: object
      properties:
        hasMore:
          type: boolean
        nodes:
          type: array
          items:
            $ref: '#/components/schemas/models.ByNode'
        page:
          type: integer
        pageSize:
          type: integer
        total:
          type: integer
      title: models.ByNodeResponse
    models.ErrorOverviewResponse:
      type: object
      properties:
        totalErrorNodes:
          type: integer
        totalErrorTypes:
          type: integer
        totalErrors:
          type: integer
      title: models.ErrorOverviewResponse
    models.ErrorLabelByError:
      type: object
      properties:
        error:
          type: string
      title: models.ErrorLabelByError
    models.ErrorTimeSeriesByError:
      type: object
      properties:
        label:
          $ref: '#/components/schemas/models.ErrorLabelByError'
        values:
          type: string
      title: models.ErrorTimeSeriesByError
    models.TimeRange:
      type: object
      properties:
        end:
          type: string
          format: date-time
        start:
          type: string
          format: date-time
      title: models.TimeRange
    models.ErrorReportGraphByErrorResponse:
      type: object
      properties:
        result:
          type: array
          items:
            $ref: '#/components/schemas/models.ErrorTimeSeriesByError'
        timeRange:
          $ref: '#/components/schemas/models.TimeRange'
      title: models.ErrorReportGraphByErrorResponse
    reports_getV1ReportsError_Response_200:
      oneOf:
        - $ref: '#/components/schemas/models.ByErrorResponse'
        - $ref: '#/components/schemas/models.ByNodeResponse'
        - $ref: '#/components/schemas/models.ErrorOverviewResponse'
        - $ref: '#/components/schemas/models.ErrorReportGraphByErrorResponse'
        - type: string
      title: reports_getV1ReportsError_Response_200
    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
{
  "totalErrorNodes": 42,
  "totalErrorTypes": 15,
  "totalErrors": 1250
}
```

**SDK Code**

```python
import requests

url = "https://api.example.com/v1/reports/error"

querystring = {"view":"list"}

response = requests.get(url, params=querystring)

print(response.json())
```

```javascript
const url = 'https://api.example.com/v1/reports/error?view=list';
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/reports/error?view=list"

	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/reports/error?view=list")

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/reports/error?view=list")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.example.com/v1/reports/error?view=list');

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

```csharp
using RestSharp;

var client = new RestClient("https://api.example.com/v1/reports/error?view=list");
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/reports/error?view=list")! 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()
```