# Checklist execution service

The Checklist Execution Service checks the status of checklist executions.

OpenAPI file: [`ChecklistExecutionService.json`](https://dev.nominal.io/api/_downloads/6f5217ed8daa1105481afc2566318747/ChecklistExecutionService.json)

## Endpoints

### Checklist live status

POST `/scout/v2/checklist-execution/checklist-live-status`

For each request, get the latest status for each check in a streaming checklist against the given asset. Requests with more than 10,000 checklists will be rejected.

Body

`requests` array of [`ChecklistLiveStatusRequest`](https://dev.nominal.io/api/rest/checklist-execution-service.md#checklistlivestatusrequest)
:   ​

    Fields of `ChecklistLiveStatusRequest`

    `checklistRid` string (RID) required
    :   ​

    `assetRid` string (RID) required
    :   ​

Response

`checklistLiveStatusResponses` array of [`ChecklistLiveStatusResponse`](https://dev.nominal.io/api/rest/checklist-execution-service.md#checklistlivestatusresponse)
:   ​

    Fields of `ChecklistLiveStatusResponse`

    `checklistRid` string (RID)
    :   ​

    `assetRid` string (RID)
    :   ​

    `status` [`ChecklistLiveStatus`](https://dev.nominal.io/api/rest/checklist-execution-service.md#checklistlivestatus)
    :   ​

        **running**

        Set `type` to `"running"`.

        `running` [`StreamingChecklistRunning`](https://dev.nominal.io/api/rest/checklist-execution-service.md#streamingchecklistrunning)
        :   The streaming checklist is currently executing against the asset.

            Fields of `StreamingChecklistRunning`

            `commitId` string
            :   The commitId of the checklist that is currently executing.

            `checkResults` array of [`CheckLiveStatusResponse`](https://dev.nominal.io/api/rest/checklist-execution-service.md#checklivestatusresponse)
            :   ​

                Fields of `CheckLiveStatusResponse`

                `status` [`CheckStatus`](https://dev.nominal.io/api/rest/checklist-execution-service.md#checkstatus)
                :   ​

                    **pass**

                    Set `type` to `"pass"`.

                    `pass` [`Pass`](https://dev.nominal.io/api/rest/checklist-execution-service.md#pass)
                    :   The check was evaluated and is currently in state PASS.

                    **fail**

                    Set `type` to `"fail"`.

                    `fail` [`Fail`](https://dev.nominal.io/api/rest/checklist-execution-service.md#fail)
                    :   The check was evaluated and is currently in state FAIL.

                    **invalid**

                    Set `type` to `"invalid"`.

                    `invalid` [`Invalid`](https://dev.nominal.io/api/rest/checklist-execution-service.md#invalid)
                    :   The check was evaluated and is currently in state INVALID. This signifies that the check could not be evaluated due to an internal error or if an overly expensive computation was attempted.

                    **skipped**

                    Set `type` to `"skipped"`.

                    `skipped` [`Skipped`](https://dev.nominal.io/api/rest/checklist-execution-service.md#skipped)
                    :   The check was skipped and was not evaluated. This typically occurs when the check performs operations that are not supported in the streaming context, or if the required channels could not be resolved.

                `checkRid` string (RID)
                :   ​

                `checkParameterIndex` integer
                :   Checks can define a single range computation which can evaluate over multiple implementations of a context. The check implementation index will correspond to the implementation index of the check condition.

        **initializing**

        Set `type` to `"initializing"`.

        `initializing` [`StreamingChecklistInitializing`](https://dev.nominal.io/api/rest/checklist-execution-service.md#streamingchecklistinitializing)
        :   The streaming checklist is currently initializing against the asset.

        **failed**

        Set `type` to `"failed"`.

        `failed` [`StreamingChecklistFailed`](https://dev.nominal.io/api/rest/checklist-execution-service.md#streamingchecklistfailed)
        :   The streaming checklist failed unexpectedly. Please contact support.

Request

**curl**

```shell
curl -X POST "https://api.gov.nominal.io/api/scout/v2/checklist-execution/checklist-live-status" \
  -H "Authorization: Bearer <api key>" \
  -H "Content-Type: application/json" \
  --data '{
  "requests": [
    {
      "checklistRid": "<checklist rid>",
      "assetRid": "<asset rid>"
    }
  ]
}'
```

**requests**

```python
import requests

response = requests.post(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/checklist-live-status",
    headers={"Authorization": "Bearer <api key>"},
    json={"requests": [{"checklistRid": "<checklist rid>", "assetRid": "<asset rid>"}]},
)
response.raise_for_status()
print(response.json())
```

**httpx**

```python
import httpx

response = httpx.post(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/checklist-live-status",
    headers={"Authorization": "Bearer <api key>"},
    json={"requests": [{"checklistRid": "<checklist rid>", "assetRid": "<asset rid>"}]},
)
response.raise_for_status()
print(response.json())
```

**aiohttp**

```python
import asyncio

import aiohttp

async def main() -> None:
    async with aiohttp.ClientSession() as session:
        async with session.post(
            "https://api.gov.nominal.io/api/scout/v2/checklist-execution/checklist-live-status",
            headers={"Authorization": "Bearer <api key>"},
            json={
                "requests": [
                    {"checklistRid": "<checklist rid>", "assetRid": "<asset rid>"},
                ],
            },
        ) as response:
            response.raise_for_status()
            print(await response.json())

asyncio.run(main())
```

Response: `200`

```json
{
  "checklistLiveStatusResponses": [
    {
      "checklistRid": "<checklist rid>",
      "assetRid": "<asset rid>",
      "status": {
        "type": "running",
        "running": {
          "commitId": "<commit id>",
          "checkResults": [
            {
              "status": {
                "type": "pass",
                "pass": {}
              },
              "checkRid": "<check rid>",
              "checkParameterIndex": 1
            }
          ]
        }
      }
    }
  ]
}
```

### Execute streaming checklist

POST `/scout/v2/checklist-execution/execute-streaming-checklist`

Triggers a checklist to run continuously against assets. If the checklist is already running for the given asset, replace the existing configuration with the one specified by the request.

Body

`checklist` string (RID) required
:   ​

`assets` array of string (RID)
:   ​

`notificationConfigurations` array of [`NotificationConfiguration`](https://dev.nominal.io/api/rest/checklist-execution-service.md#notificationconfiguration)
:   Checklist violations will be sent to the specified integrations. If empty, no notifications will be sent.

    Fields of `NotificationConfiguration`

    `integrationRid` string (RID) required
    :   ​

    `notificationFilters` array of [`NotificationFilter`](https://dev.nominal.io/api/rest/checklist-execution-service.md#notificationfilter)
    :   Specifies the type of notifications to filter. If not provided, all notifications are sent.

        Values of `NotificationFilter`

        `EXECUTION_ERROR`
        :   ​

    `appendedWorkbookRid` string (RID)
    :   If provided, appends a link to the workbook specified by the RID to the notification.

    `tags` array of string
    :   20 tags max, 50 characters max each. Tags are used to filter messages in Opsgenie. For other integrations, tags are ignored.

    `muteUntil` string (date-time)
    :   If provided, all notifications for this channel are suppressed until the specified time. The streaming checklist continues to evaluate, but no notifications are sent. Once the time has passed, notifications resume automatically.

`evaluationDelay` [`Duration`](https://dev.nominal.io/api/rest/checklist-execution-service.md#duration) required
:   Delays the evaluation of the streaming checklist. This is useful for when data is delayed.

    Fields of `Duration`

    `seconds` integer (int64) required
    :   ​

    `nanos` integer (int64) required
    :   ​

`recoveryDelay` [`Duration`](https://dev.nominal.io/api/rest/checklist-execution-service.md#duration) required
:   Specifies the minimum amount of time that must pass before a check can recover from a failure. Minimum value is 15 seconds.

`autoCreateEvents` boolean
:   The option to automatically create events for check status changes. If true, events will be created when checks fail and recover. Defaults to false if not specified.

Response

No content (HTTP 204).

Request

**curl**

```shell
curl -X POST "https://api.gov.nominal.io/api/scout/v2/checklist-execution/execute-streaming-checklist" \
  -H "Authorization: Bearer <api key>" \
  -H "Content-Type: application/json" \
  --data '{
  "checklist": "<checklist rid>",
  "evaluationDelay": {
    "seconds": 1,
    "nanos": 1
  },
  "recoveryDelay": {
    "seconds": 1,
    "nanos": 1
  }
}'
```

**requests**

```python
import requests

response = requests.post(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/execute-streaming-checklist",
    headers={"Authorization": "Bearer <api key>"},
    json={
        "checklist": "<checklist rid>",
        "evaluationDelay": {"seconds": 1, "nanos": 1},
        "recoveryDelay": {"seconds": 1, "nanos": 1},
    },
)
response.raise_for_status()
```

**httpx**

```python
import httpx

response = httpx.post(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/execute-streaming-checklist",
    headers={"Authorization": "Bearer <api key>"},
    json={
        "checklist": "<checklist rid>",
        "evaluationDelay": {"seconds": 1, "nanos": 1},
        "recoveryDelay": {"seconds": 1, "nanos": 1},
    },
)
response.raise_for_status()
```

**aiohttp**

```python
import asyncio

import aiohttp

async def main() -> None:
    async with aiohttp.ClientSession() as session:
        async with session.post(
            "https://api.gov.nominal.io/api/scout/v2/checklist-execution/execute-streaming-checklist",
            headers={"Authorization": "Bearer <api key>"},
            json={
                "checklist": "<checklist rid>",
                "evaluationDelay": {"seconds": 1, "nanos": 1},
                "recoveryDelay": {"seconds": 1, "nanos": 1},
            },
        ) as response:
            response.raise_for_status()

asyncio.run(main())
```

Response: `204`

No content.

### List streaming checklist

POST `/scout/v2/checklist-execution/list-streaming-checklists`

Lists all running streaming checklists.

Body

`pageSize` integer
:   Page sizes greater than 10_000 will be rejected. Default pageSize is 100.

`workspaces` array of string (RID)
:   ​

`pageToken` string (UUID)
:   ​

Response

`checklists` array of string (RID)
:   ​

`nextPageToken` string (UUID)
:   ​

Request

**curl**

```shell
curl -X POST "https://api.gov.nominal.io/api/scout/v2/checklist-execution/list-streaming-checklists" \
  -H "Authorization: Bearer <api key>" \
  -H "Content-Type: application/json" \
  --data '{
  "pageSize": 1,
  "workspaces": [
    "<workspace rid>"
  ],
  "pageToken": "<page token>"
}'
```

**requests**

```python
import requests

response = requests.post(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/list-streaming-checklists",
    headers={"Authorization": "Bearer <api key>"},
    json={"pageSize": 1, "workspaces": ["<workspace rid>"], "pageToken": "<page token>"},
)
response.raise_for_status()
print(response.json())
```

**httpx**

```python
import httpx

response = httpx.post(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/list-streaming-checklists",
    headers={"Authorization": "Bearer <api key>"},
    json={"pageSize": 1, "workspaces": ["<workspace rid>"], "pageToken": "<page token>"},
)
response.raise_for_status()
print(response.json())
```

**aiohttp**

```python
import asyncio

import aiohttp

async def main() -> None:
    async with aiohttp.ClientSession() as session:
        async with session.post(
            "https://api.gov.nominal.io/api/scout/v2/checklist-execution/list-streaming-checklists",
            headers={"Authorization": "Bearer <api key>"},
            json={
                "pageSize": 1,
                "workspaces": ["<workspace rid>"],
                "pageToken": "<page token>",
            },
        ) as response:
            response.raise_for_status()
            print(await response.json())

asyncio.run(main())
```

Response: `200`

```json
{
  "checklists": [
    "<checklist rid>"
  ],
  "nextPageToken": "<next page token>"
}
```

### List streaming checklist for asset

POST `/scout/v2/checklist-execution/list-streaming-checklists-for-asset`

Retrieves all streaming checklists for a given asset.

Body

`assetRid` string (RID) required
:   ​

`pageSize` integer
:   Page sizes greater than 10_000 will be rejected. Default pageSize is 100.

`pageToken` string (UUID)
:   ​

Response

`checklists` array of string (RID)
:   ​

`nextPageToken` string (UUID)
:   ​

Request

**curl**

```shell
curl -X POST "https://api.gov.nominal.io/api/scout/v2/checklist-execution/list-streaming-checklists-for-asset" \
  -H "Authorization: Bearer <api key>" \
  -H "Content-Type: application/json" \
  --data '{
  "assetRid": "<asset rid>"
}'
```

**requests**

```python
import requests

response = requests.post(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/list-streaming-checklists-for-asset",
    headers={"Authorization": "Bearer <api key>"},
    json={"assetRid": "<asset rid>"},
)
response.raise_for_status()
print(response.json())
```

**httpx**

```python
import httpx

response = httpx.post(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/list-streaming-checklists-for-asset",
    headers={"Authorization": "Bearer <api key>"},
    json={"assetRid": "<asset rid>"},
)
response.raise_for_status()
print(response.json())
```

**aiohttp**

```python
import asyncio

import aiohttp

async def main() -> None:
    async with aiohttp.ClientSession() as session:
        async with session.post(
            "https://api.gov.nominal.io/api/scout/v2/checklist-execution/list-streaming-checklists-for-asset",
            headers={"Authorization": "Bearer <api key>"},
            json={"assetRid": "<asset rid>"},
        ) as response:
            response.raise_for_status()
            print(await response.json())

asyncio.run(main())
```

Response: `200`

```json
{
  "checklists": [
    "<checklist rid>"
  ],
  "nextPageToken": "<next page token>"
}
```

### Get streaming checklist

GET `/scout/v2/checklist-execution/get-streaming-checklist/{checklistRid}`

Retrieves the set of assets and their execution configurations for a streaming checklist specified by the checklistRid.

Path parameters

`checklistRid` string (RID) required
:   ​

Response

`checklistRid` string (RID)
:   ​

`assetConfigurations` map of `AssetRid` to [`AssetStreamConfiguration`](https://dev.nominal.io/api/rest/checklist-execution-service.md#assetstreamconfiguration)
:   ​

    Fields of `AssetStreamConfiguration`

    `notificationConfigurations` array of [`NotificationConfiguration`](https://dev.nominal.io/api/rest/checklist-execution-service.md#notificationconfiguration)
    :   ​

        Fields of `NotificationConfiguration`

        `integrationRid` string (RID)
        :   ​

        `notificationFilters` array of [`NotificationFilter`](https://dev.nominal.io/api/rest/checklist-execution-service.md#notificationfilter)
        :   Specifies the type of notifications to filter. If not provided, all notifications are sent.

            Values of `NotificationFilter`

            `EXECUTION_ERROR`
            :   ​

        `appendedWorkbookRid` string (RID)
        :   If provided, appends a link to the workbook specified by the RID to the notification.

        `tags` array of string
        :   20 tags max, 50 characters max each. Tags are used to filter messages in Opsgenie. For other integrations, tags are ignored.

        `muteUntil` string (date-time)
        :   If provided, all notifications for this channel are suppressed until the specified time. The streaming checklist continues to evaluate, but no notifications are sent. Once the time has passed, notifications resume automatically.

    `evaluationDelay` [`Duration`](https://dev.nominal.io/api/rest/checklist-execution-service.md#duration)
    :   ​

        Fields of `Duration`

        `seconds` integer (int64)
        :   ​

        `nanos` integer (int64)
        :   ​

    `recoveryDelay` [`Duration`](https://dev.nominal.io/api/rest/checklist-execution-service.md#duration)
    :   ​

    `autoCreateEvents` boolean
    :   ​

Request

**curl**

```shell
curl "https://api.gov.nominal.io/api/scout/v2/checklist-execution/get-streaming-checklist/<checklist rid>" \
  -H "Authorization: Bearer <api key>"
```

**requests**

```python
import requests

response = requests.get(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/get-streaming-checklist/<checklist rid>",
    headers={"Authorization": "Bearer <api key>"},
)
response.raise_for_status()
print(response.json())
```

**httpx**

```python
import httpx

response = httpx.get(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/get-streaming-checklist/<checklist rid>",
    headers={"Authorization": "Bearer <api key>"},
)
response.raise_for_status()
print(response.json())
```

**aiohttp**

```python
import asyncio

import aiohttp

async def main() -> None:
    async with aiohttp.ClientSession() as session:
        async with session.get(
            "https://api.gov.nominal.io/api/scout/v2/checklist-execution/get-streaming-checklist/<checklist rid>",
            headers={"Authorization": "Bearer <api key>"},
        ) as response:
            response.raise_for_status()
            print(await response.json())

asyncio.run(main())
```

Response: `200`

```json
{
  "checklistRid": "<checklist rid>",
  "assetConfigurations": {
    "<key>": {
      "notificationConfigurations": [
        {
          "integrationRid": "<integration rid>",
          "notificationFilters": [
            "EXECUTION_ERROR"
          ],
          "appendedWorkbookRid": "<notebook rid>",
          "tags": [
            "<tags>"
          ],
          "muteUntil": "2026-01-01T00:00:00Z"
        }
      ],
      "evaluationDelay": {
        "seconds": 1,
        "nanos": 1
      },
      "recoveryDelay": {
        "seconds": 1,
        "nanos": 1
      },
      "autoCreateEvents": true
    }
  }
}
```

### Batch get streaming checklist

POST `/scout/v2/checklist-execution/get-streaming-checklists`

Retrieves the set of assets and their execution configurations for all streaming checklists specified by the request. If a streaming checklist is not found, it will not be included in the response.

Body

`checklistRids` array of string (RID)
:   ​

Response

`streamingChecklistInfos` map of `ChecklistRid` to [`StreamingChecklistInfo`](https://dev.nominal.io/api/rest/checklist-execution-service.md#streamingchecklistinfo)
:   ​

    Fields of `StreamingChecklistInfo`

    `checklistRid` string (RID)
    :   ​

    `assetConfigurations` map of `AssetRid` to [`AssetStreamConfiguration`](https://dev.nominal.io/api/rest/checklist-execution-service.md#assetstreamconfiguration)
    :   ​

        Fields of `AssetStreamConfiguration`

        `notificationConfigurations` array of [`NotificationConfiguration`](https://dev.nominal.io/api/rest/checklist-execution-service.md#notificationconfiguration)
        :   ​

            Fields of `NotificationConfiguration`

            `integrationRid` string (RID)
            :   ​

            `notificationFilters` array of [`NotificationFilter`](https://dev.nominal.io/api/rest/checklist-execution-service.md#notificationfilter)
            :   Specifies the type of notifications to filter. If not provided, all notifications are sent.

                Values of `NotificationFilter`

                `EXECUTION_ERROR`
                :   ​

            `appendedWorkbookRid` string (RID)
            :   If provided, appends a link to the workbook specified by the RID to the notification.

            `tags` array of string
            :   20 tags max, 50 characters max each. Tags are used to filter messages in Opsgenie. For other integrations, tags are ignored.

            `muteUntil` string (date-time)
            :   If provided, all notifications for this channel are suppressed until the specified time. The streaming checklist continues to evaluate, but no notifications are sent. Once the time has passed, notifications resume automatically.

        `evaluationDelay` [`Duration`](https://dev.nominal.io/api/rest/checklist-execution-service.md#duration)
        :   ​

            Fields of `Duration`

            `seconds` integer (int64)
            :   ​

            `nanos` integer (int64)
            :   ​

        `recoveryDelay` [`Duration`](https://dev.nominal.io/api/rest/checklist-execution-service.md#duration)
        :   ​

        `autoCreateEvents` boolean
        :   ​

Request

**curl**

```shell
curl -X POST "https://api.gov.nominal.io/api/scout/v2/checklist-execution/get-streaming-checklists" \
  -H "Authorization: Bearer <api key>" \
  -H "Content-Type: application/json" \
  --data '{
  "checklistRids": [
    "<checklist rid>"
  ]
}'
```

**requests**

```python
import requests

response = requests.post(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/get-streaming-checklists",
    headers={"Authorization": "Bearer <api key>"},
    json={"checklistRids": ["<checklist rid>"]},
)
response.raise_for_status()
print(response.json())
```

**httpx**

```python
import httpx

response = httpx.post(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/get-streaming-checklists",
    headers={"Authorization": "Bearer <api key>"},
    json={"checklistRids": ["<checklist rid>"]},
)
response.raise_for_status()
print(response.json())
```

**aiohttp**

```python
import asyncio

import aiohttp

async def main() -> None:
    async with aiohttp.ClientSession() as session:
        async with session.post(
            "https://api.gov.nominal.io/api/scout/v2/checklist-execution/get-streaming-checklists",
            headers={"Authorization": "Bearer <api key>"},
            json={"checklistRids": ["<checklist rid>"]},
        ) as response:
            response.raise_for_status()
            print(await response.json())

asyncio.run(main())
```

Response: `200`

```json
{
  "streamingChecklistInfos": {
    "<key>": {
      "checklistRid": "<checklist rid>",
      "assetConfigurations": {
        "<key>": {
          "notificationConfigurations": [
            {
              "integrationRid": "<integration rid>",
              "notificationFilters": [
                "EXECUTION_ERROR"
              ],
              "appendedWorkbookRid": "<notebook rid>",
              "tags": [
                "<tags>"
              ],
              "muteUntil": "2026-01-01T00:00:00Z"
            }
          ],
          "evaluationDelay": {
            "seconds": 1,
            "nanos": 1
          },
          "recoveryDelay": {
            "seconds": 1,
            "nanos": 1
          },
          "autoCreateEvents": true
        }
      }
    }
  }
}
```

### Stop streaming checklist

DELETE `/scout/v2/checklist-execution/stop-streaming-checklist/{checklistRid}`

Stops the execution of a streaming checklist on all assets.

Path parameters

`checklistRid` string (RID) required
:   ​

Response

No content (HTTP 204).

Request

**curl**

```shell
curl -X DELETE "https://api.gov.nominal.io/api/scout/v2/checklist-execution/stop-streaming-checklist/<checklist rid>" \
  -H "Authorization: Bearer <api key>"
```

**requests**

```python
import requests

response = requests.delete(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/stop-streaming-checklist/<checklist rid>",
    headers={"Authorization": "Bearer <api key>"},
)
response.raise_for_status()
```

**httpx**

```python
import httpx

response = httpx.delete(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/stop-streaming-checklist/<checklist rid>",
    headers={"Authorization": "Bearer <api key>"},
)
response.raise_for_status()
```

**aiohttp**

```python
import asyncio

import aiohttp

async def main() -> None:
    async with aiohttp.ClientSession() as session:
        async with session.delete(
            "https://api.gov.nominal.io/api/scout/v2/checklist-execution/stop-streaming-checklist/<checklist rid>",
            headers={"Authorization": "Bearer <api key>"},
        ) as response:
            response.raise_for_status()

asyncio.run(main())
```

Response: `204`

No content.

### Stop streaming checklist for assets

POST `/scout/v2/checklist-execution/stop-streaming-checklist-for-assets`

Stops the execution of a streaming checklist for a given set of assets.

Body

`checklist` string (RID) required
:   ​

`assets` array of string (RID)
:   ​

Response

No content (HTTP 204).

Request

**curl**

```shell
curl -X POST "https://api.gov.nominal.io/api/scout/v2/checklist-execution/stop-streaming-checklist-for-assets" \
  -H "Authorization: Bearer <api key>" \
  -H "Content-Type: application/json" \
  --data '{
  "checklist": "<checklist rid>"
}'
```

**requests**

```python
import requests

response = requests.post(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/stop-streaming-checklist-for-assets",
    headers={"Authorization": "Bearer <api key>"},
    json={"checklist": "<checklist rid>"},
)
response.raise_for_status()
```

**httpx**

```python
import httpx

response = httpx.post(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/stop-streaming-checklist-for-assets",
    headers={"Authorization": "Bearer <api key>"},
    json={"checklist": "<checklist rid>"},
)
response.raise_for_status()
```

**aiohttp**

```python
import asyncio

import aiohttp

async def main() -> None:
    async with aiohttp.ClientSession() as session:
        async with session.post(
            "https://api.gov.nominal.io/api/scout/v2/checklist-execution/stop-streaming-checklist-for-assets",
            headers={"Authorization": "Bearer <api key>"},
            json={"checklist": "<checklist rid>"},
        ) as response:
            response.raise_for_status()

asyncio.run(main())
```

Response: `204`

No content.

### Reload streaming checklist

POST `/scout/v2/checklist-execution/reload-streaming-checklist/{checklistRid}`

Reloads the state of the streaming checklist for the given checklistRid.

Path parameters

`checklistRid` string (RID) required
:   ​

Response

No content (HTTP 204).

Request

**curl**

```shell
curl -X POST "https://api.gov.nominal.io/api/scout/v2/checklist-execution/reload-streaming-checklist/<checklist rid>" \
  -H "Authorization: Bearer <api key>"
```

**requests**

```python
import requests

response = requests.post(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/reload-streaming-checklist/<checklist rid>",
    headers={"Authorization": "Bearer <api key>"},
)
response.raise_for_status()
```

**httpx**

```python
import httpx

response = httpx.post(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/reload-streaming-checklist/<checklist rid>",
    headers={"Authorization": "Bearer <api key>"},
)
response.raise_for_status()
```

**aiohttp**

```python
import asyncio

import aiohttp

async def main() -> None:
    async with aiohttp.ClientSession() as session:
        async with session.post(
            "https://api.gov.nominal.io/api/scout/v2/checklist-execution/reload-streaming-checklist/<checklist rid>",
            headers={"Authorization": "Bearer <api key>"},
        ) as response:
            response.raise_for_status()

asyncio.run(main())
```

Response: `204`

No content.

### Validate checklist resolution

POST `/scout/v2/checklist-execution/validate-checklist-resolution`

Validates that the channels referenced by the checklist can be resolved against the data sources.

Body

`requests` array of [`ValidateChecklistResolutionRequest`](https://dev.nominal.io/api/rest/checklist-execution-service.md#validatechecklistresolutionrequest)
:   ​

    Fields of `ValidateChecklistResolutionRequest`

    `checklistRid` string (RID) required
    :   ​

    `commitId` string
    :   ​

    `assetRid` string (RID) required
    :   ​

Response

`checklistResults` array of [`ValidateChecklistResolutionResponse`](https://dev.nominal.io/api/rest/checklist-execution-service.md#validatechecklistresolutionresponse)
:   ​

    Fields of `ValidateChecklistResolutionResponse`

    `checklistRid` string (RID)
    :   ​

    `assetRid` string (RID)
    :   ​

    `resolutionStatus` array of [`ResolvedCheckStatus`](https://dev.nominal.io/api/rest/checklist-execution-service.md#resolvedcheckstatus)
    :   ​

        Fields of `ResolvedCheckStatus`

        `checkRid` string (RID)
        :   ​

        `checkParameterIndex` integer
        :   Checks can define a single range computation which can evaluate over multiple implementations of a context. The check implementation index will correspond to the implementation index of the check condition.

        `invalidStreamingComputeNodes` array of [`InvalidStreamingComputeNode`](https://dev.nominal.io/api/rest/checklist-execution-service.md#invalidstreamingcomputenode)
        :   ​

            Values of `InvalidStreamingComputeNode`

            `POINT_PERSISTENCE`
            :   ​

            `CUMULATIVE_SUM`
            :   ​

            `INTEGRAL`
            :   ​

            `STALENESS_DETECTION`
            :   ​

            `LITERAL_RANGES`
            :   ​

            `LITERAL_ENUM_SERIES`
            :   ​

            `TAG_BY_INTERVALS`
            :   ​

            `NUMERIC_COMBINE_WITH_TAGS`
            :   ​

            `PHASE_UNWRAP`
            :   ​

            `RUN_WITH_FIXED_END`
            :   ​

            `TIME_RANGE_FILTER_WITH_FIXED_END`
            :   ​

        `channels` array of [`ChannelLocatorWithStatus`](https://dev.nominal.io/api/rest/checklist-execution-service.md#channellocatorwithstatus)
        :   ​

            Fields of `ChannelLocatorWithStatus`

            `channelLocator` [`ChannelLocator`](https://dev.nominal.io/api/rest/checklist-execution-service.md#channellocator)
            :   ​

                Fields of `ChannelLocator`

                `dataSourceRef` string
                :   ​

                `channel` string
                :   ​

                `tags` map of `TagName` to string
                :   ​

                `asset` string
                :   ​

                `run` string
                :   ​

                `inputId` string
                :   ​

            `resolutionStatus` [`ChannelResolutionStatus`](https://dev.nominal.io/api/rest/checklist-execution-service.md#channelresolutionstatus)
            :   ​

                Values of `ChannelResolutionStatus`

                `RESOLVED`
                :   ​

                `UNRESOLVED`
                :   ​

        `resolutionError` [`SerializableError`](https://dev.nominal.io/api/rest/checklist-execution-service.md#serializableerror)
        :   Why the check’s compute graph could not be resolved. A streaming checklist skips this check.

            Fields of `SerializableError`

            `name` string
            :   ​

            `message` string
            :   ​

            `errorInstanceId` string
            :   ​

            `statusCode` integer
            :   ​

            `params` map of string to string
            :   ​

Request

**curl**

```shell
curl -X POST "https://api.gov.nominal.io/api/scout/v2/checklist-execution/validate-checklist-resolution" \
  -H "Authorization: Bearer <api key>" \
  -H "Content-Type: application/json" \
  --data '{
  "requests": [
    {
      "checklistRid": "<checklist rid>",
      "assetRid": "<asset rid>"
    }
  ]
}'
```

**requests**

```python
import requests

response = requests.post(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/validate-checklist-resolution",
    headers={"Authorization": "Bearer <api key>"},
    json={"requests": [{"checklistRid": "<checklist rid>", "assetRid": "<asset rid>"}]},
)
response.raise_for_status()
print(response.json())
```

**httpx**

```python
import httpx

response = httpx.post(
    "https://api.gov.nominal.io/api/scout/v2/checklist-execution/validate-checklist-resolution",
    headers={"Authorization": "Bearer <api key>"},
    json={"requests": [{"checklistRid": "<checklist rid>", "assetRid": "<asset rid>"}]},
)
response.raise_for_status()
print(response.json())
```

**aiohttp**

```python
import asyncio

import aiohttp

async def main() -> None:
    async with aiohttp.ClientSession() as session:
        async with session.post(
            "https://api.gov.nominal.io/api/scout/v2/checklist-execution/validate-checklist-resolution",
            headers={"Authorization": "Bearer <api key>"},
            json={
                "requests": [
                    {"checklistRid": "<checklist rid>", "assetRid": "<asset rid>"},
                ],
            },
        ) as response:
            response.raise_for_status()
            print(await response.json())

asyncio.run(main())
```

Response: `200`

```json
{
  "checklistResults": [
    {
      "checklistRid": "<checklist rid>",
      "assetRid": "<asset rid>",
      "resolutionStatus": [
        {
          "checkRid": "<check rid>",
          "checkParameterIndex": 1,
          "invalidStreamingComputeNodes": [
            "POINT_PERSISTENCE"
          ],
          "channels": [
            {
              "channelLocator": {
                "dataSourceRef": "<data source ref name>",
                "channel": "<channel>",
                "tags": {
                  "<key>": "<tag value>"
                },
                "asset": "<asset ref name>",
                "run": "<run ref name>",
                "inputId": "<input id>"
              },
              "resolutionStatus": "RESOLVED"
            }
          ],
          "resolutionError": {
            "name": "<name>",
            "message": "<message>",
            "errorInstanceId": "<error instance id>",
            "statusCode": 1,
            "params": {
              "<key>": "<value>"
            }
          }
        }
      ]
    }
  ]
}
```

## Errors

[Errors](https://dev.nominal.io/api/legacy.md#errors) shows how these errors are sent.

Each error’s `errorName` is `ChecklistExecution:` followed by its name below.

| Status | Name | Notes |
| --- | --- | --- |
| 400 | `CheckNotAvailableInStreamingContext` |  |
| 400 | `ChecklistAlreadyRunning` |  |
| 400 | `ConnectionNotAvailableForStreaming` |  |
| 404 | `StreamingChecklistNotFound` |  |
| 404 | `StreamingChecklistNotFoundForAsset` |  |

## Types

### AssetStreamConfiguration

`notificationConfigurations` array of [`NotificationConfiguration`](https://dev.nominal.io/api/rest/checklist-execution-service.md#notificationconfiguration)
:   ​

`evaluationDelay` [`Duration`](https://dev.nominal.io/api/rest/checklist-execution-service.md#duration) required
:   ​

`recoveryDelay` [`Duration`](https://dev.nominal.io/api/rest/checklist-execution-service.md#duration) required
:   ​

`autoCreateEvents` boolean required
:   ​

### ChannelLocator

`dataSourceRef` string required
:   ​

`channel` string required
:   ​

`tags` map of `TagName` to string
:   ​

`asset` string
:   ​

`run` string
:   ​

`inputId` string
:   ​

### ChannelLocatorWithStatus

`channelLocator` [`ChannelLocator`](https://dev.nominal.io/api/rest/checklist-execution-service.md#channellocator) required
:   ​

`resolutionStatus` [`ChannelResolutionStatus`](https://dev.nominal.io/api/rest/checklist-execution-service.md#channelresolutionstatus) required
:   ​

### ChannelResolutionStatus

`RESOLVED`
:   ​

`UNRESOLVED`
:   ​

### ChecklistLiveStatus

Set `type` to the name of one of the other fields, and set only that field.

`running` [`StreamingChecklistRunning`](https://dev.nominal.io/api/rest/checklist-execution-service.md#streamingchecklistrunning)
:   The streaming checklist is currently executing against the asset.

`initializing` [`StreamingChecklistInitializing`](https://dev.nominal.io/api/rest/checklist-execution-service.md#streamingchecklistinitializing)
:   The streaming checklist is currently initializing against the asset.

`failed` [`StreamingChecklistFailed`](https://dev.nominal.io/api/rest/checklist-execution-service.md#streamingchecklistfailed)
:   The streaming checklist failed unexpectedly. Please contact support.

### ChecklistLiveStatusRequest

`checklistRid` string (RID) required
:   ​

`assetRid` string (RID) required
:   ​

### ChecklistLiveStatusResponse

`checklistRid` string (RID) required
:   ​

`assetRid` string (RID) required
:   ​

`status` [`ChecklistLiveStatus`](https://dev.nominal.io/api/rest/checklist-execution-service.md#checklistlivestatus) required
:   ​

### CheckLiveStatusResponse

`status` [`CheckStatus`](https://dev.nominal.io/api/rest/checklist-execution-service.md#checkstatus) required
:   ​

`checkRid` string (RID) required
:   ​

`checkParameterIndex` integer
:   Checks can define a single range computation which can evaluate over multiple implementations of a context. The check implementation index will correspond to the implementation index of the check condition.

### CheckStatus

Set `type` to the name of one of the other fields, and set only that field.

`pass` [`Pass`](https://dev.nominal.io/api/rest/checklist-execution-service.md#pass)
:   The check was evaluated and is currently in state PASS.

`fail` [`Fail`](https://dev.nominal.io/api/rest/checklist-execution-service.md#fail)
:   The check was evaluated and is currently in state FAIL.

`invalid` [`Invalid`](https://dev.nominal.io/api/rest/checklist-execution-service.md#invalid)
:   The check was evaluated and is currently in state INVALID. This signifies that the check could not be evaluated due to an internal error or if an overly expensive computation was attempted.

`skipped` [`Skipped`](https://dev.nominal.io/api/rest/checklist-execution-service.md#skipped)
:   The check was skipped and was not evaluated. This typically occurs when the check performs operations that are not supported in the streaming context, or if the required channels could not be resolved.

### Duration

`seconds` integer (int64) required
:   ​

`nanos` integer (int64) required
:   ​

### Fail

An empty JSON object, `{}`.

### Invalid

An empty JSON object, `{}`.

### InvalidStreamingComputeNode

`POINT_PERSISTENCE`
:   ​

`CUMULATIVE_SUM`
:   ​

`INTEGRAL`
:   ​

`STALENESS_DETECTION`
:   ​

`LITERAL_RANGES`
:   ​

`LITERAL_ENUM_SERIES`
:   ​

`TAG_BY_INTERVALS`
:   ​

`NUMERIC_COMBINE_WITH_TAGS`
:   ​

`PHASE_UNWRAP`
:   ​

`RUN_WITH_FIXED_END`
:   ​

`TIME_RANGE_FILTER_WITH_FIXED_END`
:   ​

### NotificationConfiguration

Configuration details to send notifications to a linked integration.

`integrationRid` string (RID) required
:   ​

`notificationFilters` array of [`NotificationFilter`](https://dev.nominal.io/api/rest/checklist-execution-service.md#notificationfilter)
:   Specifies the type of notifications to filter. If not provided, all notifications are sent.

`appendedWorkbookRid` string (RID)
:   If provided, appends a link to the workbook specified by the RID to the notification.

`tags` array of string
:   20 tags max, 50 characters max each. Tags are used to filter messages in Opsgenie. For other integrations, tags are ignored.

`muteUntil` string (date-time)
:   If provided, all notifications for this channel are suppressed until the specified time. The streaming checklist continues to evaluate, but no notifications are sent. Once the time has passed, notifications resume automatically.

### NotificationFilter

Specifies a type of notification to filter.

`EXECUTION_ERROR`
:   ​

### Pass

An empty JSON object, `{}`.

### ResolvedCheckStatus

Provides the resolution status for the required channels for a check and the set of invalid streaming compute nodes present within the check’s compute graph. Uniqueness between checkRid and checkParameterIndex pairs is guaranteed.

`checkRid` string (RID) required
:   ​

`checkParameterIndex` integer
:   Checks can define a single range computation which can evaluate over multiple implementations of a context. The check implementation index will correspond to the implementation index of the check condition.

`invalidStreamingComputeNodes` array of [`InvalidStreamingComputeNode`](https://dev.nominal.io/api/rest/checklist-execution-service.md#invalidstreamingcomputenode)
:   ​

`channels` array of [`ChannelLocatorWithStatus`](https://dev.nominal.io/api/rest/checklist-execution-service.md#channellocatorwithstatus)
:   ​

`resolutionError` [`SerializableError`](https://dev.nominal.io/api/rest/checklist-execution-service.md#serializableerror)
:   Why the check’s compute graph could not be resolved. A streaming checklist skips this check.

### SerializableError

A SerializableError is a representation of a ServiceException that exists to send error results to clients as part of a response object when directly throwing an exception is undesirable.

`name` string required
:   ​

`message` string
:   ​

`errorInstanceId` string required
:   ​

`statusCode` integer required
:   ​

`params` map of string to string
:   ​

### Skipped

An empty JSON object, `{}`.

### StreamingChecklistFailed

An empty JSON object, `{}`.

### StreamingChecklistInfo

`checklistRid` string (RID) required
:   ​

`assetConfigurations` map of `AssetRid` to [`AssetStreamConfiguration`](https://dev.nominal.io/api/rest/checklist-execution-service.md#assetstreamconfiguration)
:   ​

### StreamingChecklistInitializing

An empty JSON object, `{}`.

### StreamingChecklistRunning

`commitId` string required
:   The commitId of the checklist that is currently executing.

`checkResults` array of [`CheckLiveStatusResponse`](https://dev.nominal.io/api/rest/checklist-execution-service.md#checklivestatusresponse)
:   ​

### ValidateChecklistResolutionRequest

Validates that the channels referenced by the checklist can be resolved against the data sources. If commit is not provided, the latest commit on main will be used.

`checklistRid` string (RID) required
:   ​

`commitId` string
:   ​

`assetRid` string (RID) required
:   ​

### ValidateChecklistResolutionResponse

`checklistRid` string (RID) required
:   ​

`assetRid` string (RID) required
:   ​

`resolutionStatus` array of [`ResolvedCheckStatus`](https://dev.nominal.io/api/rest/checklist-execution-service.md#resolvedcheckstatus)
:   ​

Page design based on [Scalar](https://scalar.com), MIT License.