## List Evaluation Dashboards

`evaluation_dashboards.list(EvaluationDashboardListParams**kwargs)  -> SyncCursorPage[EvaluationDashboard]`

**get** `/v5/evaluation-dashboards`

List dashboards in the caller's account, paginated, with optional filters.

Filter to a single evaluation with `evaluation_id` or to a group with
`evaluation_group_id`; passing both is rejected, since a dashboard is bound to one
or the other. `tags` matches case-insensitively (values are lowercased before
lookup), `created_by_ids` filters by creator identity, and `search` matches the
dashboard name and tags. Archived dashboards are excluded unless `include_archived`
is true. The returned items carry only the dashboards' own fields — widgets and
widget results are never embedded here; use the get-by-id endpoint with the
`widgets`/`widget_results` views to load those.

### Parameters

- `created_by_ids: Optional[Sequence[str]]`

  Filter by creator user IDs

- `ending_before: Optional[str]`

- `evaluation_group_id: Optional[str]`

- `evaluation_id: Optional[str]`

- `include_archived: Optional[bool]`

- `limit: Optional[int]`

- `search: Optional[str]`

  Search in name and tags

- `sort_by: Optional[str]`

- `sort_order: Optional[SortOrder]`

  - `"asc"`

  - `"desc"`

- `starting_after: Optional[str]`

- `tags: Optional[Sequence[str]]`

  Filter by tags (case-insensitive)

### Returns

- `class EvaluationDashboard: …`

  - `id: str`

    Unique identifier of the dashboard

  - `account_id: str`

    Account that owns this dashboard

  - `created_at: datetime`

    When the dashboard was created

  - `created_by: Identity`

    The identity that created the entity.

    - `id: str`

    - `type: Literal["user", "service_account"]`

      - `"user"`

      - `"service_account"`

    - `object: Optional[Literal["identity"]]`

      - `"identity"`

  - `name: str`

    Dashboard name

  - `tags: Optional[List[str]]`

    The tags associated with the entity

  - `updated_at: datetime`

    When the dashboard was last updated

  - `archived_at: Optional[datetime]`

    When the dashboard was archived (soft-deleted)

  - `description: Optional[str]`

    Dashboard description

  - `error_message: Optional[str]`

    Error message if computation failed

  - `evaluation_group_id: Optional[str]`

    Evaluation group ID

  - `evaluation_id: Optional[str]`

    Evaluation ID

  - `object: Optional[Literal["evaluation_dashboard"]]`

    - `"evaluation_dashboard"`

  - `widget_order: Optional[List[str]]`

    Ordered array of widget IDs

  - `widget_results: Optional[List[EvaluationDashboardWidgetResult]]`

    Widget results for this dashboard. Populated with 'widget_results' view.

    - `id: str`

      Unique identifier of the widget result

    - `account_id: str`

      Account that owns this widget result

    - `computation_status: Literal["pending", "completed", "failed"]`

      Status of the computation

      - `"pending"`

      - `"completed"`

      - `"failed"`

    - `created_at: datetime`

      When the widget result was created

    - `widget_id: str`

      Unique identifier of the widget

    - `computation_job_id: Optional[str]`

      Temporal workflow ID or job ID for async computation tracking

    - `computed_at: Optional[datetime]`

      Timestamp when computation completed successfully

    - `computed_result: Optional[Dict[str, object]]`

      Cached computation results

    - `error_message: Optional[str]`

      Error message if computation failed

    - `evaluation_group_id: Optional[str]`

      FK to evaluation_groups. Null if result is for a single evaluation.

    - `evaluation_id: Optional[str]`

      FK to evaluations. Null if result is for an evaluation group.

    - `object: Optional[Literal["evaluation_dashboard_widget_result"]]`

      - `"evaluation_dashboard_widget_result"`

    - `widget: Optional[EvaluationDashboardWidget]`

      Widget that this result is for

      - `id: str`

        Unique identifier of the widget

      - `account_id: str`

        Account that owns this widget

      - `created_at: datetime`

        When the widget was created

      - `title: str`

        Widget title

      - `type: EvaluationWidgetTypeEnum`

        Widget type

        - `"bar"`

        - `"histogram"`

        - `"donut"`

        - `"scatter"`

        - `"metric"`

        - `"table"`

        - `"markdown"`

        - `"heading"`

        - `"timeseries"`

      - `archived_at: Optional[datetime]`

        When the widget was archived (soft-deleted)

      - `config: Optional[Dict[str, object]]`

        Chart-specific display configuration

      - `object: Optional[Literal["evaluation_dashboard_widget"]]`

        - `"evaluation_dashboard_widget"`

      - `query: Optional[Query]`

        Structured query AST for metric computation (SeriesQuery or MetricQuery)

        - `class SeriesQuery: …`

          Query that returns a series of records (used for table/bar/histogram/donut/scatter widgets).

          Used for widget types: table, bar, histogram, donut, scatter.
          Returns: {"type": "series", "data": [...]}

          Example SQL equivalent:
          SELECT category, AVG(score) as avg_score, COUNT(*) as count
          FROM evaluation_items
          WHERE score > 0.5 AND category = 'test'
          GROUP BY category
          ORDER BY avg_score DESC
          LIMIT 100

          - `select: List[SelectItem]`

            - `expression: Expression`

              Reference to a column from evaluation_items.data

              Example:
              {"type": "COLUMN", "column": "category"}

              - `class ExpressionColumn: …`

                Reference to a column from evaluation_items.data

                Example:
                {"type": "COLUMN", "column": "category"}

                - `column: str`

                  Column name from evaluation_items.data

                - `source: Optional[str]`

                  Column source: 'data' or 'task_result_cache'

                - `type: Optional[Literal["COLUMN"]]`

                  - `"COLUMN"`

              - `class ExpressionAggregation: …`

                Aggregation function to apply

                Examples:
                {"type": "AGGREGATION", "function": "AVG", "column": "score"}
                {"type": "AGGREGATION", "function": "COUNT", "column": "*"}
                {"type": "AGGREGATION", "function": "PERCENTILE", "column": "score", "params": {"percentile": 95}}

                - `column: str`

                  Column to aggregate, or '*' for COUNT(*)

                - `function: Literal["COUNT", "SUM", "AVG", 7 more]`

                  Supported aggregation functions

                  - `"COUNT"`

                  - `"SUM"`

                  - `"AVG"`

                  - `"MIN"`

                  - `"MAX"`

                  - `"STDDEV"`

                  - `"VARIANCE"`

                  - `"PERCENTILE"`

                  - `"COUNT_DISTINCT"`

                  - `"PERCENTAGE"`

                - `evaluation_ids: Optional[List[str]]`

                  Optional subset of evaluation IDs for per-aggregation filtering in evaluation group dashboards.

                - `params: Optional[Dict[str, object]]`

                  Function parameters (e.g., {'percentile': 95} for PERCENTILE, {'percentage_filters': Filter} for PERCENTAGE)

                - `source: Optional[str]`

                  Column source: 'data' or 'task_result_cache'

                - `type: Optional[Literal["AGGREGATION"]]`

                  - `"AGGREGATION"`

            - `alias: Optional[str]`

              Optional alias for the selected item

          - `evaluation_ids: Optional[List[str]]`

            Optional subset of evaluation IDs to compute on. Only applicable for evaluation group dashboards. If omitted, computes on all evaluations in the group.

          - `filter: Optional[Filter]`

            Filter conditions (WHERE clause)

            - `conditions: List[Condition]`

              - `column: str`

                Column name to filter on

              - `operator: Literal["=", "!=", ">", 9 more]`

                Comparison operator

                - `"="`

                - `"!="`

                - `">"`

                - `"<"`

                - `">="`

                - `"<="`

                - `"IN"`

                - `"NOT IN"`

                - `"LIKE"`

                - `"NOT LIKE"`

                - `"IS NULL"`

                - `"IS NOT NULL"`

              - `source: Optional[str]`

                Column source: 'data' or 'task_result_cache'

              - `value: Optional[Union[str, float, bool, 2 more]]`

                Value to compare against. Not required for IS NULL / IS NOT NULL operators.

                - `str`

                - `float`

                - `bool`

                - `List[object]`

            - `logical_operators: Optional[List[Literal["AND", "OR"]]]`

              Logical operators connecting conditions. Length must be len(conditions) - 1

              - `"AND"`

              - `"OR"`

          - `group_by: Optional[List[str]]`

            Columns to group by

          - `latest_only: Optional[bool]`

            When True, the widget computes against rows from only the most recent active evaluation in the group (by EvaluationORM.created_at). Only applicable for evaluation group dashboards. Composes with evaluation_ids (latest within the subset). Cannot be combined with per-aggregation evaluation_ids; the use case enforces these rules.

          - `limit: Optional[int]`

            Max rows to return

          - `order_by: Optional[List[OrderBy]]`

            Sort order

            - `column: str`

              Column name to sort by

            - `direction: Optional[Literal["ASC", "DESC"]]`

              Sort direction

              - `"ASC"`

              - `"DESC"`

            - `source: Optional[str]`

              Column source: 'data' or 'task_result_cache'

        - `class MetricQuery: …`

          Query that returns a single metric value (used for metric widgets).

          Used for widget type: metric.
          Enforces exactly 1 aggregation in select.
          Returns: {"type": "metric", "data": ...}

          Example SQL equivalent:
          SELECT AVG(score) as average_score
          FROM evaluation_items

          - `select: List[SelectItem]`

            - `expression: Expression`

              Reference to a column from evaluation_items.data

              Example:
              {"type": "COLUMN", "column": "category"}

            - `alias: Optional[str]`

              Optional alias for the selected item

          - `evaluation_ids: Optional[List[str]]`

            Optional subset of evaluation IDs to compute on. Only applicable for evaluation group dashboards. If omitted, computes on all evaluations in the group.

          - `filter: Optional[Filter]`

            Filter conditions (WHERE clause)

          - `latest_only: Optional[bool]`

            When True, the widget computes against rows from only the most recent active evaluation in the group (by EvaluationORM.created_at). Only applicable for evaluation group dashboards. Composes with evaluation_ids (latest within the subset). Cannot be combined with per-aggregation evaluation_ids; the use case enforces these rules.

  - `widgets: Optional[List[EvaluationDashboardWidget]]`

    Widgets associated with this dashboard. Populated with 'widgets' view.

    - `id: str`

      Unique identifier of the widget

    - `account_id: str`

      Account that owns this widget

    - `created_at: datetime`

      When the widget was created

    - `title: str`

      Widget title

    - `type: EvaluationWidgetTypeEnum`

      Widget type

    - `archived_at: Optional[datetime]`

      When the widget was archived (soft-deleted)

    - `config: Optional[Dict[str, object]]`

      Chart-specific display configuration

    - `object: Optional[Literal["evaluation_dashboard_widget"]]`

    - `query: Optional[Query]`

      Structured query AST for metric computation (SeriesQuery or MetricQuery)

### Example

```python
import os
from scale_gp_beta import SGPClient

client = SGPClient(
    api_key=os.environ.get("SGP_API_KEY"),  # This is the default and can be omitted
)
page = client.evaluation_dashboards.list()
page = page.items[0]
print(page.id)
```

#### Response

```json
{
  "has_more": true,
  "items": [
    {
      "id": "id",
      "account_id": "account_id",
      "created_at": "2019-12-27T18:11:19.117Z",
      "created_by": {
        "id": "id",
        "type": "user",
        "object": "identity"
      },
      "name": "name",
      "tags": [
        "string"
      ],
      "updated_at": "2019-12-27T18:11:19.117Z",
      "archived_at": "2019-12-27T18:11:19.117Z",
      "description": "description",
      "error_message": "error_message",
      "evaluation_group_id": "evaluation_group_id",
      "evaluation_id": "evaluation_id",
      "object": "evaluation_dashboard",
      "widget_order": [
        "string"
      ],
      "widget_results": [
        {
          "id": "id",
          "account_id": "account_id",
          "computation_status": "pending",
          "created_at": "2019-12-27T18:11:19.117Z",
          "widget_id": "widget_id",
          "computation_job_id": "computation_job_id",
          "computed_at": "2019-12-27T18:11:19.117Z",
          "computed_result": {
            "foo": "bar"
          },
          "error_message": "error_message",
          "evaluation_group_id": "evaluation_group_id",
          "evaluation_id": "evaluation_id",
          "object": "evaluation_dashboard_widget_result",
          "widget": {
            "id": "id",
            "account_id": "account_id",
            "created_at": "2019-12-27T18:11:19.117Z",
            "title": "title",
            "type": "bar",
            "archived_at": "2019-12-27T18:11:19.117Z",
            "config": {
              "foo": "bar"
            },
            "object": "evaluation_dashboard_widget",
            "query": {
              "select": [
                {
                  "expression": {
                    "column": "column",
                    "source": "source",
                    "type": "COLUMN"
                  },
                  "alias": "alias"
                }
              ],
              "evaluation_ids": [
                "string"
              ],
              "filter": {
                "conditions": [
                  {
                    "column": "column",
                    "operator": "=",
                    "source": "source",
                    "value": "string"
                  }
                ],
                "logicalOperators": [
                  "AND"
                ]
              },
              "groupBy": [
                "string"
              ],
              "latest_only": true,
              "limit": 1,
              "orderBy": [
                {
                  "column": "column",
                  "direction": "ASC",
                  "source": "source"
                }
              ]
            }
          }
        }
      ],
      "widgets": [
        {
          "id": "id",
          "account_id": "account_id",
          "created_at": "2019-12-27T18:11:19.117Z",
          "title": "title",
          "type": "bar",
          "archived_at": "2019-12-27T18:11:19.117Z",
          "config": {
            "foo": "bar"
          },
          "object": "evaluation_dashboard_widget",
          "query": {
            "select": [
              {
                "expression": {
                  "column": "column",
                  "source": "source",
                  "type": "COLUMN"
                },
                "alias": "alias"
              }
            ],
            "evaluation_ids": [
              "string"
            ],
            "filter": {
              "conditions": [
                {
                  "column": "column",
                  "operator": "=",
                  "source": "source",
                  "value": "string"
                }
              ],
              "logicalOperators": [
                "AND"
              ]
            },
            "groupBy": [
              "string"
            ],
            "latest_only": true,
            "limit": 1,
            "orderBy": [
              {
                "column": "column",
                "direction": "ASC",
                "source": "source"
              }
            ]
          }
        }
      ]
    }
  ],
  "total": 0,
  "limit": 0,
  "object": "list"
}
```