---
updatedAt: 2026-08-18T13:22:17.000Z
agentTools:
  siteIndex: https://techdocs.akamai.com/llms.txt
  projectIndex: https://techdocs.akamai.com/linode-api/llms.txt
---

# List Valkey Managed Databases

__Limited availability__ Display all accessible Valkey Managed Databases.


**Permissions and scopes**

To call this operation, you need the following:

- **Identity and access permissions**. Your user needs these roles assigned. [Learn more](https://techdocs.akamai.com/cloud-computing/docs/identity-access-cm-available-roles).
  - Roles: `database_viewer`
- **OAuth scopes**. Your user needs these scopes assigned. [Learn more](https://techdocs.akamai.com/linode-api/reference/get-started#oauth).

  - Scopes: `databases:read_only`

# OpenAPI definition

```json
{
  "components": {
    "securitySchemes": {
      "oauth": {
        "flows": {
          "authorizationCode": {
            "authorizationUrl": "https://login.linode.com/oauth/authorize",
            "scopes": {
              "account:read_only": "Allows access to GET information about your account.",
              "account:read_write": "Allows access to all endpoints related to your account.",
              "child_account:read_only": "Allows access to GET information about deprecated parent/child operations.",
              "child_account:read_write": "Allows access to deprecated parent/child operations.",
              "databases:read_only": "Allows access to GET information about databases.",
              "databases:read_write": "Allows access to all endpoints related to databases.",
              "domains:read_only": "Allows access to GET Domains on your account.",
              "domains:read_write": "Allows access to all Domain endpoints.",
              "events:read_only": "Allows access to GET your Events.",
              "events:read_write": "Allows access to all endpoints related to your Events.",
              "firewall:read_only": "Allows access to GET information about your Firewalls.",
              "firewall:read_write": "Allows access to all Firewall endpoints.",
              "images:read_only": "Allows access to GET your Images.",
              "images:read_write": "Allows access to all endpoints related to your Images.",
              "ips:read_only": "Allows access to GET your ips.",
              "ips:read_write": "Allows access to all endpoints related to your ips.",
              "linodes:read_only": "Allows access to GET Linodes on your account.",
              "linodes:read_write": "Allow access to all endpoints related to your Linodes.",
              "lke:read_only": "Allows access to GET LKE Clusters on your account.",
              "lke:read_write": "Allows access to all endpoints related to LKE Clusters on your account.",
              "longview:read_only": "Allows access to GET your Longview Clients.",
              "longview:read_write": "Allows access to all endpoints related to your Longview Clients.",
              "monitor:read_only": "Allows access to Monitor (Akamai Cloud Pulse) data.",
              "monitor:read_write": "Allows access to GET Monitor (Akamai Cloud Pulse) data.",
              "nodebalancers:read_only": "Allows access to GET NodeBalancers on your account.",
              "nodebalancers:read_write": "Allows access to all NodeBalancer endpoints.",
              "object_storage:read_only": "Allows access to GET information related to your Object Storage.",
              "object_storage:read_write": "Allows access to all Object Storage endpoints.",
              "stackscripts:read_only": "Allows access to GET your StackScripts.",
              "stackscripts:read_write": "Allows access to all endpoints related to your StackScripts.",
              "volumes:read_only": "Allows access to GET your Volumes.",
              "volumes:read_write": "Allows access to all endpoints related to your Volumes.",
              "vpc:read_write": "Allows access to all endpoints related to VPC and Subnet creation, updating, and deletion."
            },
            "tokenUrl": "https://login.linode.com/oauth/token"
          }
        },
        "type": "oauth2"
      },
      "personalAccessToken": {
        "scheme": "bearer",
        "type": "http"
      }
    }
  },
  "externalDocs": {
    "description": "See documentation for Akamai's Linode API",
    "url": "https://techdocs.akamai.com/linode-api/reference"
  },
  "info": {
    "description": "\"[Read the API documentation](https://techdocs.akamai.com/linode-api/reference/api).\"",
    "license": {
      "name": "Apache 2.0",
      "url": "https://www.apache.org/licenses/LICENSE-2.0.html"
    },
    "title": "Databases",
    "version": "4.229.1"
  },
  "openapi": "3.0.1",
  "paths": {
    "/{apiVersion}/databases/valkey/instances": {
      "get": {
        "description": "__Limited availability__ Display all accessible Valkey Managed Databases.\n\n\n**Permissions and scopes**\n\nTo call this operation, you need the following:\n\n- **Identity and access permissions**. Your user needs these roles assigned. [Learn more](https://techdocs.akamai.com/cloud-computing/docs/identity-access-cm-available-roles).\n  - Roles: `database_viewer`\n- **OAuth scopes**. Your user needs these scopes assigned. [Learn more](https://techdocs.akamai.com/linode-api/reference/get-started#oauth).\n\n  - Scopes: `databases:read_only`",
        "externalDocs": {
          "description": "See documentation for this operation in Akamai's Linode API",
          "url": "https://techdocs.akamai.com/linode-api/reference/get-databases-valkey-instances"
        },
        "operationId": "get-databases-valkey-instances",
        "parameters": [
          {
            "description": "The page of a collection to return.",
            "in": "query",
            "name": "page",
            "required": false,
            "schema": {
              "default": 1,
              "example": 6,
              "minimum": 1,
              "type": "integer"
            },
            "x-akamai": {
              "file-path": "parameters/page-offset.yaml"
            }
          },
          {
            "description": "The number of items to return per page.",
            "in": "query",
            "name": "page_size",
            "schema": {
              "default": 100,
              "example": 50,
              "maximum": 500,
              "minimum": 25,
              "type": "integer"
            },
            "x-akamai": {
              "file-path": "parameters/page-size.yaml"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "example": {
                  "data": [
                    {
                      "allow_list": [],
                      "available_restore_times": [
                        "2025-12-29T20:40:15"
                      ],
                      "cluster_size": 1,
                      "created": "2025-12-29T20:29:15",
                      "encrypted": true,
                      "engine": "valkey",
                      "engine_config": {
                        "frequent_snapshots": true,
                        "valkey_active_expire_effort": 1,
                        "valkey_lfu_decay_time": 1,
                        "valkey_lfu_log_factor": 10,
                        "valkey_maxmemory_policy": "noeviction",
                        "valkey_timeout": 300
                      },
                      "hosts": {
                        "primary": "a29-akamai-testuser-1000-default.g2a.akamaidb.net"
                      },
                      "id": 29,
                      "label": "sampledb-valkey",
                      "members": {},
                      "port": 13670,
                      "private_network": null,
                      "region": "us-east",
                      "ssl_connection": true,
                      "status": "provisioning",
                      "total_disk_size_gb": 0,
                      "type": "g6-nanode-1",
                      "updated": "2025-12-29T20:29:16",
                      "updates": {
                        "day_of_week": 7,
                        "duration": 4,
                        "frequency": "weekly",
                        "hour_of_day": 15,
                        "pending": []
                      },
                      "used_disk_size_gb": null,
                      "version": "8.1"
                    },
                    {
                      "allow_list": [],
                      "available_restore_times": [
                        "2025-12-29T20:40:15"
                      ],
                      "cluster_size": 1,
                      "created": "2025-12-29T20:29:15",
                      "encrypted": true,
                      "engine": "valkey",
                      "engine_config": {
                        "frequent_snapshots": true,
                        "valkey_active_expire_effort": 1,
                        "valkey_lfu_decay_time": 1,
                        "valkey_lfu_log_factor": 10,
                        "valkey_maxmemory_policy": "noeviction",
                        "valkey_timeout": 300
                      },
                      "hosts": {
                        "primary": "a30-akamai-testuser-1000-default.g2a.akamaidb.net"
                      },
                      "id": 30,
                      "label": "sampledb-valkey",
                      "members": {},
                      "port": 13670,
                      "private_network": null,
                      "region": "us-east",
                      "ssl_connection": true,
                      "status": "provisioning",
                      "total_disk_size_gb": 0,
                      "type": "g6-nanode-1",
                      "updated": "2025-12-29T20:29:16",
                      "updates": {
                        "day_of_week": 7,
                        "duration": 4,
                        "frequency": "weekly",
                        "hour_of_day": 15,
                        "pending": []
                      },
                      "used_disk_size_gb": null,
                      "version": "8.1"
                    }
                  ],
                  "page": 1,
                  "pages": 1,
                  "results": 2
                },
                "schema": {
                  "additionalProperties": false,
                  "properties": {
                    "data": {
                      "description": "A list of objects returned for a response.",
                      "items": {
                        "additionalProperties": false,
                        "description": "Managed Valkey Databases object.",
                        "properties": {
                          "allow_list": {
                            "description": "Controls access to the Managed Database.\n\n- Individually included IP addresses or CIDR ranges can access the Managed Database while all other sources are blocked.\n\n- A standalone value of `0.0.0.0/0` allows all IP addresses access to the Managed Database.\n\n- An empty array (`[]`) blocks all public and private connections to the Managed Database.",
                            "example": [
                              "203.0.113.1/32",
                              "192.0.1.0/24"
                            ],
                            "items": {
                              "format": "ipv4/prefix_length",
                              "pattern": "^([0-9]{1,3}\\.){3}[0-9]{1,3}(\\/([0-9]|[1-2][0-9]|3[0-2]))?$",
                              "type": "string"
                            },
                            "minItems": 0,
                            "type": "array"
                          },
                          "available_restore_times": {
                            "description": "__Read-only__ Possible times you can create a fork from for a Valkey database.",
                            "items": {
                              "example": "2024-10-03T20:48:05",
                              "type": "string"
                            },
                            "minItems": 0,
                            "readOnly": true,
                            "type": "array"
                          },
                          "cluster_size": {
                            "default": 1,
                            "description": "The number of Linode instance nodes deployed to the Managed Database, from `1` to `3`. Consider these points when setting a `cluster_size`:\n\n- Choose `3` nodes to create a high availability cluster that consists of one `primary` node and two `standby` nodes.\n\n- A `2` node cluster is only available with a dedicated plan. It consists of one `primary` node and one `standby` node.",
                            "enum": [
                              1,
                              2,
                              3
                            ],
                            "example": 3,
                            "type": "integer",
                            "x-linode-cli-display": 5
                          },
                          "created": {
                            "description": "__Read-only__ When this Managed Database was created.",
                            "example": "2022-01-01T00:01:01",
                            "readOnly": true,
                            "type": "string"
                          },
                          "encrypted": {
                            "default": true,
                            "description": "__Read-only__ Whether the Managed Databases is encrypted. Currently the only possible value is `true`.",
                            "example": true,
                            "readOnly": true,
                            "type": "boolean"
                          },
                          "engine": {
                            "description": "__Filterable__, __Read-only__ The Managed Database engine type.",
                            "example": "valkey",
                            "readOnly": true,
                            "type": "string",
                            "x-akamai": {
                              "labels": [
                                "Filterable"
                              ]
                            },
                            "x-linode-cli-display": 6,
                            "x-linode-filterable": true
                          },
                          "engine_config": {
                            "additionalProperties": false,
                            "description": "Advanced parameters applied to a Valkey Managed Database, via our partner [Aiven's specification](https://aiven.io/docs/products/valkey/reference/advanced-params). Only include the objects for parameters you want to set in your database. Omit objects for parameters you don't want to define or change.\n\n> 📘\n>\n> Aiven may offer additional parameters in their specification. Currently, only those listed here are supported for use in a Valkey Managed Database. You can also run the [Get Valkey Managed Database advanced parameters](https://techdocs.akamai.com/linode-api/reference/get-databases-valkey-config) operation to see an up-to-date list.",
                            "properties": {
                              "backup_hour": {
                                "description": "The hour of day (in UTC) when the backup for the service starts. New backups only start if the previous backup has already completed.",
                                "maximum": 23,
                                "minimum": 0,
                                "type": "integer"
                              },
                              "backup_minute": {
                                "description": "The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed.",
                                "maximum": 23,
                                "minimum": 0,
                                "nullable": true,
                                "type": "integer"
                              },
                              "frequent_snapshots": {
                                "description": "When enabled, Valkey creates frequent local RDB snapshots. When disabled, Valkey only takes RDB snapshots when a backup is created, based on the backup schedule. This setting is ignored when `valkey_persistence` is set to off.",
                                "type": "boolean"
                              },
                              "valkey_acl_channels_default": {
                                "description": "Default ACL for pub/sub channels used when a Valkey user is created. Determines default pub/sub channels' ACL for new users if ACL is not supplied. When this option is not defined, all_channels is assumed to keep backward compatibility. This option doesn't affect Valkey configuration acl-pubsub-default.",
                                "type": "string"
                              },
                              "valkey_active_expire_effort": {
                                "default": 1,
                                "description": "Active expire effort. Valkey reclaims expired keys both when accessed and in the background. The background process scans for expired keys to free memory. Increasing the active-expire-effort setting uses more CPU to reclaim expired keys faster, reducing memory usage but potentially increasing latency.",
                                "maximum": 10,
                                "minimum": 1,
                                "type": "integer"
                              },
                              "valkey_activedefrag": {
                                "default": false,
                                "description": "Enables active memory defragmentation. When enabled, Valkey relocates objects off sparsely-used memory pages to reduce fragmentation and return memory to the operating system. Defragmentation runs on the main thread and consumes CPU, so it may increase latency under load.",
                                "example": false,
                                "type": "boolean"
                              },
                              "valkey_lfu_decay_time": {
                                "default": 1,
                                "description": "LFU maxmemory-policy counter decay time in minutes.",
                                "maximum": 120,
                                "minimum": 1,
                                "type": "integer"
                              },
                              "valkey_lfu_log_factor": {
                                "default": 10,
                                "description": "Counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory-policies.",
                                "maximum": 100,
                                "type": "integer"
                              },
                              "valkey_maxmemory_policy": {
                                "default": "noeviction",
                                "description": "Valkey maxmemory-policy.",
                                "nullable": true,
                                "type": "string"
                              },
                              "valkey_number_of_databases": {
                                "description": "Set number of Valkey databases. Changing this will cause a restart of the Valkey service.",
                                "maximum": 128,
                                "minimum": 1,
                                "type": "integer"
                              },
                              "valkey_persistence": {
                                "default": "rdb",
                                "description": "- If set to `rdb`, Valkey generates periodic snapshots at least according to the backup schedule (either every twelve hours with an initial time chosen by the system or every 24 hours based on `backup_hour` and `backup_minute`, if set). Combined with the `frequent_snapshots` parameter set to `true`, Valkey generates snapshots every ten minutes if data has changed, which limits data loss in case nodes have to restart for any reason.\n\n- If set to `off`, Valkey never takes snapshots. This means no backups and no possibility of restoring the cluster. Service restarts are guaranteed to lose data. The benefit is avoiding the performance penalty creating a snapshot entails.\n\n> 📘\n>\n>`valkey_persistence` can't be set `off`, if `backup_hour` or `backup_minute` are configured. When set to `off`, you can't configure the maintentace window when [Updating a Valkey Managed Database](https://techdocs.akamai.com/linode-api/reference/put-databases-valkey-instance).",
                                "enum": [
                                  "off",
                                  "rdb"
                                ],
                                "type": "string"
                              },
                              "valkey_pubsub_client_output_buffer_limit": {
                                "description": "Set output buffer limit for pub / sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.",
                                "maximum": 262144,
                                "minimum": 32,
                                "type": "integer"
                              },
                              "valkey_timeout": {
                                "default": 300,
                                "description": "Valkey idle connection timeout in seconds.",
                                "maximum": 2073600,
                                "type": "integer"
                              }
                            },
                            "type": "object",
                            "x-akamai": {
                              "file-path": "schemas/database-valkey-engine-config.yaml"
                            },
                            "x-linode-cli-display": 7
                          },
                          "fork": {
                            "additionalProperties": false,
                            "description": "Details on the database that was the target of the fork. This only exists if the database was restored by creating a fork from another database.",
                            "properties": {
                              "restore_time": {
                                "description": "The database timestamp from which it was restored. This is _not_ when the fork was created.",
                                "example": "2024-10-14T19:55:12",
                                "type": "string"
                              },
                              "source": {
                                "description": "The unique identifier for the database that was forked from.",
                                "example": 176881,
                                "type": "integer"
                              }
                            },
                            "type": "object"
                          },
                          "hosts": {
                            "additionalProperties": false,
                            "description": "__Read-only__ The primary hostname and standby read-only hostname for the Managed Database. The API assigns these hostnames after it successfully creates the Managed Database.",
                            "properties": {
                              "endpoints": {
                                "description": "__Read-only__ A structured inventory of all connection points for a Managed Database instance.",
                                "items": {
                                  "additionalProperties": false,
                                  "properties": {
                                    "address": {
                                      "description": "The DNS hostname that resolves to either the `primary` or `standby` host, based on this object's `role`.",
                                      "example": "lin-123-456-mysql-mysql-primary.servers.linodedb.net",
                                      "type": "string"
                                    },
                                    "port": {
                                      "description": "The port number used for the connection.",
                                      "example": 3306,
                                      "type": "integer"
                                    },
                                    "public_access": {
                                      "description": "Whether `public_access` has been enabled for the connection point.",
                                      "example": false,
                                      "type": "boolean"
                                    },
                                    "role": {
                                      "description": "Whether the endpoint connects to the `primary` or `standby` hostname, as defined in `hosts`.",
                                      "enum": [
                                        "primary",
                                        "standby"
                                      ],
                                      "example": "primary",
                                      "type": "string"
                                    }
                                  },
                                  "type": "object"
                                },
                                "readOnly": true,
                                "type": "array"
                              },
                              "primary": {
                                "description": "The primary hostname for the Managed Database.\n\n> 📘\n>\n> - If you've configured the Managed Database to use a Virtual Private Cloud (VPC) via the `private_network` object ([MySQL](https://techdocs.akamai.com/linode-api/reference/post-databases-mysql-instances) / [PostgreSQL](https://techdocs.akamai.com/linode-api/reference/post-databases-postgre-sql-instances)), this hostname resolves to a private IPv4 address within that VPC subnet's address range.\n>\n> - With `public_access` enabled in a `private_network`, a public version of this hostname is also available. Resolving this hostname returns publicly routable IPv4 and IPv6 addresses.",
                                "example": "lin-123-456-mysql-mysql-primary.servers.linodedb.net",
                                "format": "hostname",
                                "nullable": true,
                                "type": "string"
                              },
                              "standby": {
                                "description": "A DNS name that resolves to the IP addresses assigned to the Managed Database's read-only standby hosts. You can use this hostname to configure applications that only need to view data in the database, in an effort to limit the load on the `primary`.\n\n> 📘\n>\n> - This only applies to Managed Databases with a `cluster_size` of `2` or `3`.\n>\n> - This DNS name is publicly visible and accessible. Connections to it are over the public internet unless the Managed Database is inside a VPC.\n>\n> - Network traffic to this DNS name is billable unless the client connects over IPv6 from the same `region`.\n>\n> - If you've configured the Managed Database to use a VPC via the `private_network` object ([MySQL](https://techdocs.akamai.com/linode-api/reference/post-databases-mysql-instances) / [PostgreSQL](https://techdocs.akamai.com/linode-api/reference/post-databases-postgre-sql-instances)), this hostname resolves to one or more private IPv4 addresses within that VPC subnet's address range.\n>\n> - With `public_access` enabled in a `private_network`, a public version of this hostname is also available. Resolving this hostname returns publicly routable IPv4 and IPv6 addresses.",
                                "example": "lin-123-456-mysql-primary-private.servers.linodedb.net",
                                "nullable": true,
                                "type": "string"
                              }
                            },
                            "readOnly": true,
                            "type": "object"
                          },
                          "id": {
                            "description": "__Read-only__ A unique ID that can be used to identify and reference the Managed Database.",
                            "example": 123,
                            "readOnly": true,
                            "type": "integer",
                            "x-linode-cli-display": 1
                          },
                          "label": {
                            "description": "__Filterable__ A name used to identify the Managed Database. This needs to be unique per Managed Database `engine` type. For example, you could use `database_1`, `database_2`, and `database_3` for three unique MySQL Managed Databases. You can also use these same names for three unique PostgreSQL Managed Databases. However, you can't repeat any of these names for either engine type.",
                            "example": "example-db",
                            "maxLength": 32,
                            "minLength": 3,
                            "type": "string",
                            "x-akamai": {
                              "labels": [
                                "Filterable"
                              ]
                            },
                            "x-linode-cli-display": 2,
                            "x-linode-filterable": true
                          },
                          "members": {
                            "additionalProperties": {
                              "enum": [
                                "primary",
                                "failover"
                              ],
                              "type": "string"
                            },
                            "description": "__Read-only__ A mapping between IP addresses and strings designating them as `primary` or `failover`.",
                            "example": {
                              "45.56.110.70": "primary",
                              "45.79.159.239": "failover"
                            },
                            "readOnly": true,
                            "type": "object"
                          },
                          "platform": {
                            "description": "__Filterable__, __Read-only__ The back-end platform for relational databases used by the service, either `rdbms-legacy` or `rdbms-default`.",
                            "enum": [
                              "rdbms-legacy",
                              "rdbms-default"
                            ],
                            "example": "rdbms-default",
                            "readOnly": true,
                            "type": "string",
                            "x-akamai": {
                              "labels": [
                                "Filterable"
                              ]
                            },
                            "x-linode-cli-display": 8,
                            "x-linode-filterable": true
                          },
                          "port": {
                            "description": "__Read-only__ The access port for this Managed Database.",
                            "example": 3306,
                            "readOnly": true,
                            "type": "integer"
                          },
                          "private_network": {
                            "additionalProperties": false,
                            "description": "Restricts access on a Managed Database to a specific Virtual Private Cloud (VPC) configured for the cluster. Displayed as `null` if no VPC is configured.",
                            "nullable": true,
                            "properties": {
                              "public_access": {
                                "default": false,
                                "description": "Set to `true` allows clients outside of the VPC to connect to the database using a public IP address.\n\n> 📘\n>\n> If your Managed Database is also configured using an `allow_list`, only IP addresses set in it can access that database, even if this object is set to `true`.",
                                "example": true,
                                "type": "boolean"
                              },
                              "subnet_id": {
                                "description": "The VPC's `subnet_id` used to control access to the database.",
                                "example": 456,
                                "type": "integer"
                              },
                              "vpc_id": {
                                "description": "The unique identifier of the VPC you want to use to enable private access to the Managed Database.",
                                "example": 123,
                                "type": "integer"
                              }
                            },
                            "type": "object"
                          },
                          "region": {
                            "description": "__Filterable__ The unique identifier for the [region](https://techdocs.akamai.com/linode-api/reference/get-regions) where the Managed Database lives.",
                            "example": "us-east",
                            "type": "string",
                            "x-akamai": {
                              "labels": [
                                "Filterable"
                              ]
                            },
                            "x-linode-cli-display": 3,
                            "x-linode-filterable": true
                          },
                          "ssl_connection": {
                            "default": true,
                            "description": "Currently required to be `true`. Whether to require SSL credentials to establish a connection to the Managed Database. Run the [Get Valkey Managed Database credentials](https://techdocs.akamai.com/linode-api/reference/get-databases-valkey-instance-credentials) operation for access information.",
                            "example": true,
                            "type": "boolean"
                          },
                          "status": {
                            "description": "__Filterable__, __Read-only__ The operating status of the Managed Database, which can be one of the following: `provisioning`, `active`, `suspending`, `suspended`, `resuming`, `updating`, or `resizing`.",
                            "enum": [
                              "provisioning",
                              "active",
                              "suspending",
                              "suspended",
                              "resuming",
                              "updating",
                              "resizing"
                            ],
                            "example": "active",
                            "readOnly": true,
                            "type": "string",
                            "x-akamai": {
                              "labels": [
                                "Filterable"
                              ]
                            },
                            "x-linode-cli-color": {
                              "active": "green",
                              "default_": "white",
                              "degraded": "red",
                              "failed": "red",
                              "provisioning": "yellow",
                              "restoring": "yellow",
                              "resuming": "yellow"
                            },
                            "x-linode-cli-display": 100,
                            "x-linode-filterable": true
                          },
                          "total_disk_size_gb": {
                            "description": "__Read-only__ The total disk size of the database, in GB.",
                            "example": 15,
                            "readOnly": true,
                            "type": "integer"
                          },
                          "type": {
                            "description": "__Filterable__ The `id` of the Linode Instance type used by the Managed Database for its nodes.",
                            "example": "g6-dedicated-2",
                            "type": "string",
                            "x-akamai": {
                              "labels": [
                                "Filterable"
                              ]
                            },
                            "x-linode-cli-display": 4,
                            "x-linode-filterable": true
                          },
                          "updated": {
                            "description": "__Read-only__ When this Managed Database was last updated.",
                            "example": "2022-01-01T00:01:01",
                            "readOnly": true,
                            "type": "string"
                          },
                          "updates": {
                            "additionalProperties": false,
                            "description": "Configuration settings for automated patch update maintenance for the Managed Database.",
                            "properties": {
                              "day_of_week": {
                                "description": "The numeric reference for the day of the week to perform maintenance. `1` is Monday, `2` is Tuesday, through to `7` which is Sunday.",
                                "example": 1,
                                "maximum": 7,
                                "minimum": 1,
                                "type": "integer"
                              },
                              "duration": {
                                "default": 4,
                                "description": "The maximum maintenance window time in hours. Currently can only be `4`.",
                                "example": 4,
                                "type": "integer"
                              },
                              "frequency": {
                                "default": "weekly",
                                "description": "How frequently maintenance occurs. Currently can only be `weekly`.",
                                "enum": [
                                  "weekly"
                                ],
                                "example": "weekly",
                                "type": "string"
                              },
                              "hour_of_day": {
                                "description": "The hour to begin maintenance based in UTC time.",
                                "example": 0,
                                "maximum": 23,
                                "minimum": 0,
                                "type": "integer"
                              },
                              "pending": {
                                "description": "__Read-only__ An array of pending updates.",
                                "example": [],
                                "items": {
                                  "additionalProperties": false,
                                  "description": "A planned maintenance update.",
                                  "properties": {
                                    "deadline": {
                                      "description": "The time when a mandatory update needs to be applied.",
                                      "example": "2024-10-14T19:55:12",
                                      "nullable": true,
                                      "type": "string"
                                    },
                                    "description": {
                                      "description": "A description of the update.",
                                      "example": "TimescaleDB version 2.17.1 is available.",
                                      "type": "string"
                                    },
                                    "planned_for": {
                                      "description": "The time when a maintenance update will be applied.",
                                      "example": "2024-10-14T19:55:12",
                                      "nullable": true,
                                      "type": "string"
                                    }
                                  },
                                  "type": "object"
                                },
                                "minItems": 0,
                                "readOnly": true,
                                "type": "array"
                              }
                            },
                            "type": "object"
                          },
                          "used_disk_size_gb": {
                            "description": "__Read-only__ The amount of space currently in use in the database, in GB. This is `null` for Valkey",
                            "example": 2,
                            "nullable": true,
                            "readOnly": true,
                            "type": "integer"
                          },
                          "version": {
                            "description": "__Filterable__ The Managed Database engine version.",
                            "example": "13.2",
                            "type": "string",
                            "x-akamai": {
                              "labels": [
                                "Filterable"
                              ]
                            },
                            "x-linode-cli-display": 7,
                            "x-linode-filterable": true
                          }
                        },
                        "type": "object",
                        "x-akamai": {
                          "file-path": "schemas/database-valkey.yaml"
                        }
                      },
                      "type": "array"
                    },
                    "page": {
                      "description": "__Read-only__ The current [page](https://techdocs.akamai.com/linode-api/reference/pagination).",
                      "example": 1,
                      "readOnly": true,
                      "type": "integer"
                    },
                    "pages": {
                      "description": "__Read-only__ The total number of [pages](https://techdocs.akamai.com/linode-api/reference/pagination).",
                      "example": 1,
                      "readOnly": true,
                      "type": "integer"
                    },
                    "results": {
                      "description": "__Read-only__ The total number of results.",
                      "example": 1,
                      "readOnly": true,
                      "type": "integer"
                    }
                  },
                  "type": "object",
                  "x-akamai": {
                    "file-path": "schemas/get-databases-valkey-instances-200.yaml"
                  }
                }
              }
            },
            "description": "Returns a paginated list of all accessible Valkey Managed Databases on your account."
          },
          "default": {
            "content": {
              "application/json": {
                "example": {
                  "errors": [
                    {
                      "reason": "Invalid JSON"
                    }
                  ]
                },
                "schema": {
                  "additionalProperties": false,
                  "properties": {
                    "errors": {
                      "description": "Any warnings associated with a response.",
                      "items": {
                        "additionalProperties": false,
                        "description": "An object for describing a single error that occurred during the processing of a request.",
                        "properties": {
                          "field": {
                            "description": "The field in the request that caused this error. This may be a path, separated by periods in the case of nested fields. In some cases this may come back as `null` if the error is not specific to any single element of the request.",
                            "example": "fieldname",
                            "type": "string"
                          },
                          "reason": {
                            "description": "What happened to cause this error. In most cases, this can be fixed immediately by changing the data you sent in the request, but in some cases you will be instructed to [Open a support ticket](https://techdocs.akamai.com/linode-api/reference/post-ticket) or perform some other action before you can complete the request successfully.",
                            "example": "fieldname must be a valid value",
                            "type": "string"
                          }
                        },
                        "type": "object",
                        "x-akamai": {
                          "file-path": "schemas/error-object.yaml"
                        }
                      },
                      "type": "array"
                    }
                  },
                  "type": "object"
                }
              }
            },
            "description": "See [Errors](https://techdocs.akamai.com/linode-api/reference/errors) for the range of possible error response codes."
          }
        },
        "security": [
          {
            "personalAccessToken": []
          },
          {
            "oauth": [
              "databases:read_only"
            ]
          }
        ],
        "summary": "List Valkey Managed Databases",
        "tags": [
          "Valkey"
        ],
        "x-akamai": {
          "status": "LA"
        },
        "x-linode-cli-action": "valkey-list",
        "x-linode-grant": "read_only",
        "x-linode-iam": [
          {
            "roles": [
              "database_viewer"
            ]
          }
        ]
      },
      "parameters": [
        {
          "description": "__Enum__ Call either the `v4` URL, or `v4beta` for operations still in Beta.",
          "in": "path",
          "name": "apiVersion",
          "required": true,
          "schema": {
            "enum": [
              "v4",
              "v4beta"
            ],
            "example": "v4",
            "type": "string"
          },
          "x-akamai": {
            "file-path": "parameters/api-version-path.yaml"
          }
        }
      ],
      "x-akamai": {
        "file-path": "paths/valkey-instances.yaml",
        "path-info": "/{apiVersion}/databases/valkey/instances"
      },
      "x-linode-cli-command": "databases"
    }
  },
  "servers": [
    {
      "url": "https://api.linode.com"
    }
  ],
  "tags": [
    {
      "description": "Managed Databases is Akamai's fully-managed, high-performance database service. Use these operations to create and manage clusters for Valkey engine databases.",
      "name": "Valkey"
    }
  ],
  "x-akamai": {
    "auth-type": "OAUTH",
    "file-path": "databases.yaml"
  },
  "x-readme": {
    "apply-tag-changes": true,
    "explorer-enabled": false,
    "samples-languages": [
      "curl",
      "python",
      "node"
    ]
  }
}
```

# Sibling pages

* [List Valkey Managed Database advanced parameters](https://techdocs.akamai.com/linode-api/reference/get-databases-valkey-config.md)
* [Create or restore a Valkey Managed Database](https://techdocs.akamai.com/linode-api/reference/post-databases-valkey-instances.md)
* [Get a Valkey Managed Database](https://techdocs.akamai.com/linode-api/reference/get-databases-valkey-instance.md)
* [Update a Valkey Managed Database](https://techdocs.akamai.com/linode-api/reference/put-databases-valkey-instance.md)
* [Delete a Valkey Managed Database](https://techdocs.akamai.com/linode-api/reference/delete-databases-valkey-instance.md)
* [Get Valkey Managed Database credentials](https://techdocs.akamai.com/linode-api/reference/get-databases-valkey-instance-credentials.md)
* [Reset Valkey Managed Database credentials](https://techdocs.akamai.com/linode-api/reference/post-databases-valkey-instance-credentials-reset.md)
* [Patch a Valkey Managed Database](https://techdocs.akamai.com/linode-api/reference/post-databases-valkey-instance-patch.md)
* [Resume a Valkey Managed Database](https://techdocs.akamai.com/linode-api/reference/resume-databases-valkey-instance.md)
* [Get a Valkey Managed Database SSL certificate](https://techdocs.akamai.com/linode-api/reference/get-databases-valkey-instance-ssl.md)
* [Suspend a Valkey Managed Database](https://techdocs.akamai.com/linode-api/reference/suspend-databases-valkey-instance.md)