> 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 complete timeline for a specific alert (level 3)

GET /v1/alert_timeline/nodes/{nodeUUID}/alerts/{alertUUID}

Get complete timeline for a specific alert. Returns alert UUID, component, current alertStatus, nodeGroup, computeZone, and complete event timeline. This is the third level of the progressive disclosure API for alert timelines. Events default to newest-first (most recent update first); pass order=asc for chronological (oldest-first) order. Pagination of the timeline events is optional and backward compatible: omit pageSize to receive the full timeline (default); supply pageSize to page through the events, in which case the response also carries page/pageSize/total/hasMore metadata.

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

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: fleet-intelligence
  version: 1.0.0
paths:
  /v1/alert_timeline/nodes/{nodeUUID}/alerts/{alertUUID}:
    get:
      operationId: getV1AlertTimelineNodesNodeUuidAlertsAlertUuid
      summary: Get complete timeline for a specific alert (level 3)
      description: >-
        Get complete timeline for a specific alert. Returns alert UUID,
        component, current alertStatus, nodeGroup, computeZone, and complete
        event timeline. This is the third level of the progressive disclosure
        API for alert timelines. Events default to newest-first (most recent
        update first); pass order=asc for chronological (oldest-first) order.
        Pagination of the timeline events is optional and backward compatible:
        omit pageSize to receive the full timeline (default); supply pageSize to
        page through the events, in which case the response also carries
        page/pageSize/total/hasMore metadata.
      tags:
        - alerts
      parameters:
        - name: nodeUUID
          in: path
          description: Node UUID
          required: true
          schema:
            type: string
        - name: alertUUID
          in: path
          description: Alert UUID
          required: true
          schema:
            type: string
        - name: order
          in: query
          description: >-
            Sort direction on event time: 'desc' (default, most recent update
            first) or 'asc' (chronological, oldest first)
          required: false
          schema:
            $ref: >-
              #/components/schemas/V1AlertTimelineNodesNodeUuidAlertsAlertUuidGetParametersOrder
            default: desc
        - name: page
          in: query
          description: Page number (0-indexed); only applied when pageSize is supplied
          required: false
          schema:
            type: integer
            default: 0
        - name: pageSize
          in: query
          description: >-
            Timeline events per page (1-100). Omit for the full, unpaginated
            timeline (default behavior)
          required: false
          schema:
            type: integer
      responses:
        '200':
          description: Complete timeline for the alert
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/models.AlertTimelineDetailResponse'
        '400':
          description: Bad Request - Invalid UUID format
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/models.ErrorResponse'
        '401':
          description: Unauthorized
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/models.ErrorResponse'
        '404':
          description: Alert 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'
components:
  schemas:
    V1AlertTimelineNodesNodeUuidAlertsAlertUuidGetParametersOrder:
      type: string
      enum:
        - asc
        - desc
      default: desc
      title: V1AlertTimelineNodesNodeUuidAlertsAlertUuidGetParametersOrder
    models.AlertEventType:
      type: string
      enum:
        - detected
        - triggered
        - resolved
        - retriggered
        - severity_changed
        - metadata_updated
        - notify_sent
        - notify_failed
        - muted
        - unmuted
        - burst_analyzed
      title: models.AlertEventType
    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.AlertTimelineEvent:
      type: object
      properties:
        alertStatus:
          type: string
          description: '"Critical"/"Warning" if Triggered, "Detected"/"Resolved" otherwise'
        error:
          type: string
        eventTimestamp:
          type: string
        eventType:
          $ref: '#/components/schemas/models.AlertEventType'
        extraInfo:
          type: object
          additionalProperties:
            description: Any type
        incidents:
          type: array
          items:
            description: Any type
        message:
          type: string
        suggestedActions:
          type: array
          items:
            $ref: '#/components/schemas/models.SuggestedAction'
      title: models.AlertTimelineEvent
    models.AlertTimelineDetailResponse:
      type: object
      properties:
        alertStatus:
          type: string
          description: 'Current alert status: severity if active, state if resolved/detected'
        alertUuid:
          type: string
        component:
          type: string
        componentDisplayName:
          type: string
        computeZone:
          type: string
          description: Compute zone display name from node inventory
        customerID:
          type: string
        hasMore:
          type: boolean
        isBackendComponent:
          type: boolean
        nodeGroup:
          type: string
          description: Node group display name from node inventory
        nodeUuid:
          type: string
        page:
          type: integer
          description: >-
            Pagination metadata for the timeline events. These fields are
            populated only when the caller

            opts into pagination by supplying the pageSize query parameter; they
            are omitted entirely

            otherwise, so existing clients that expect the full, unpaginated
            timeline are unaffected.

            When present, Timeline holds only the requested page (order
            controlled by query param) and Total

            is the count of all timeline events for the alert.
        pageSize:
          type: integer
        timeline:
          type: array
          items:
            $ref: '#/components/schemas/models.AlertTimelineEvent'
          description: >-
            Sorted by eventTimestamp (default DESC = newest-first; query param
            order=asc reverses)
        total:
          type: integer
      title: models.AlertTimelineDetailResponse
    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
{
  "alertStatus": "Critical",
  "alertUuid": "550e8400-e29b-41d4-a716-446655440000",
  "component": "GPU",
  "componentDisplayName": "GPU",
  "computeZone": "Compute Zone Name",
  "customerID": "customer-123",
  "hasMore": true,
  "isBackendComponent": true,
  "nodeGroup": "Node Group Name 1",
  "nodeUuid": "node-uuid-456",
  "page": 0,
  "pageSize": 50,
  "timeline": [
    {
      "alertStatus": "Critical",
      "error": "Temperature critically high",
      "eventTimestamp": "2024-12-01T10:00:00Z",
      "eventType": "detected",
      "extraInfo": {},
      "incidents": [
        null
      ],
      "message": "GPU critical temperature alert",
      "suggestedActions": [
        {
          "action": "Restart the application",
          "code": "RESTART_APP",
          "persona": "tenant",
          "type": "immediate"
        }
      ]
    }
  ],
  "total": 120
}
```

**SDK Code**

```python
import requests

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

response = requests.get(url)

print(response.json())
```

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

	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/alert_timeline/nodes/nodeUUID/alerts/alertUUID")

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/alert_timeline/nodes/nodeUUID/alerts/alertUUID")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

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

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

```csharp
using RestSharp;

var client = new RestClient("https://api.example.com/v1/alert_timeline/nodes/nodeUUID/alerts/alertUUID");
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/alert_timeline/nodes/nodeUUID/alerts/alertUUID")! 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()
```