DataStax
Astra DevOps API

The Astra DevOps API is the administrative control-plane API for DataStax Astra DB. It provides programmatic management of serverless and classic databases, keyspaces, datacenters, access lists, organization roles and users, application tokens, private-link and VPC peering, customer keys, telemetry, change-data-capture (CDC), regions, PCU groups, SCIM 2.0 user provisioning, and enterprise/migration operations. Authentication is a bearer application token.
Documentation GitHub OpenAPI
OpenAPI Specification

{
  "openapi": "3.0.0",
  "info": {
    "description": "Use this REST API to manage your DataStax Astra DB organizations and perform lifecycle actions for your Astra DB databases.</br> </br> To get started, use the /v2/clientIdSecrets endpoints to create a token to authenticate your API calls.",
    "version": "2.3.0",
    "title": "Astra DevOps API",
    "contact": {
      "email": "ad-astra@datastax.com"
    }
  },
  "security": [
    {
      "BearerAuth": [
        "org-admin",
        "org-db-create",
        "org-db-terminate",
        "org-db-view",
        "org-db-expand",
        "org-db-suspend",
        "org-db-addpeering",
        "org-db-readpeering",
        "db-keyspace-create",
        "db-cql",
        "accesslist-write",
        "accesslist-read",
        "db-manage-privateendpoint",
        "db-manage-telemetry",
        "db-manage-backupconfiguration"
      ]
    }
  ],
  "tags": [
    {
      "name": "Authentication",
      "description": "Generate and revoke tokens that are used to authenticate DevOps API operations."
    },
    {
      "name": "Database Operations",
      "description": "Use these DevOps APIs to manage Astra databases."
    },
    {
      "name": "Organization Operations",
      "description": "DevOps APIs for your Astra organization."
    },
    {
      "name": "Enterprise Operations",
      "description": "DevOps APIs for your Astra enterprise."
    },
    {
      "name": "Roles",
      "description": "Use the DevOps Roles APIs to manage roles in your Astra organization."
    },
    {
      "name": "Users",
      "description": "Use the DevOps Users APIs to manage users in your Astra organization."
    },
    {
      "name": "Token",
      "description": "Generate and revoke tokens that are used to authenticate DevOps API operations."
    },
    {
      "name": "Access List",
      "description": "View, create, modify, or delete the IP access list for an Astra database."
    },
    {
      "name": "DevOps Access List",
      "description": "View, create, modify, or delete the access list that restricts access to the DevOps API for an Astra organization."
    },
    {
      "name": "Private Link",
      "description": "Use the DevOps Private Link APIs to manage private link endpoints for your Astra databases."
    },
    {
      "name": "VPC Peering",
      "description": "Use the DevOps VPC Peering APIs to manage VPC peering for Managed Cluster (Classic) databases."
    },
    {
      "name": "Customer Keys",
      "description": "Manage customer keys for your Astra organization."
    },
    {
      "name": "Regions",
      "description": "Get available regions by database type, user, or organization."
    },
    {
      "name": "Migrations",
      "description": "Use the DevOps API to manage SSTables-based migrations."
    },
    {
      "name": "Clone",
      "description": "Use the DevOps API to clone databases."
    },
    {
      "name": "PCU",
      "description": "Use the DevOps API to manage provisioned capacity units for eligible organizations and databases."
    },
    {
      "name": "SCIM",
      "description": "SCIM 2.0 endpoints for user and group provisioning and management."
    }
  ],
  "paths": {
    "/v2/tokens": {
      "post": {
        "tags": [
          "Authentication",
          "Token"
        ],
        "summary": "Create a new AstraCS token",
        "operationId": "createToken",
        "requestBody": {
          "description": "The model for creating a token",
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreateTokenBody"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/GenerateTokenResponse"
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "500": {
            "$ref": "#/components/responses/ServerError"
          }
        }
      },
      "get": {
        "tags": [
          "Authentication",
          "Token"
        ],
        "summary": "Get a list of tokens for an org",
        "operationId": "getTokensForOrg",
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "items": {
                    "$ref": "#/components/schemas/ClientRoleList"
                  }
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "500": {
            "$ref": "#/components/responses/ServerError"
          }
        }
      },
      "delete": {
        "tags": [
          "Authentication",
          "Token"
        ],
        "summary": "Deletes a token",
        "operationId": "deleteToken",
        "parameters": [
          {
            "$ref": "#/components/parameters/ClientIdParam"
          }
        ],
        "responses": {
          "200": {
            "$ref": "#/components/responses/Ok"
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "500": {
            "$ref": "#/components/responses/ServerError"
          }
        }
      }
    },
    "/v2/clientIdSecrets": {
      "get": {
        "tags": [
          "Authentication",
          "Token"
        ],
        "summary": "Get a list of clients for an org",
        "operationId": "getClientsForOrg",
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "items": {
                    "$ref": "#/components/schemas/ClientRoleList"
                  }
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "500": {
            "$ref": "#/components/responses/ServerError"
          }
        }
      },
      "post": {
        "tags": [
          "Authentication",
          "Token"
        ],
        "summary": "generateTokenForClient",
        "operationId": "generateTokenForClient",
        "requestBody": {
          "description": "The model for generating token for client",
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/GenerateTokenBody"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "items": {
                    "$ref": "#/components/schemas/GenerateTokenResponse"
                  }
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "500": {
            "$ref": "#/components/responses/ServerError"
          }
        }
      }
    },
    "/v2/clientIdSecrets/{clientId}": {
      "delete": {
        "tags": [
          "Authentication",
          "Token"
        ],
        "summary": "Revokes a token",
        "operationId": "deleteTokenForClient",
        "parameters": [
          {
            "$ref": "#/components/parameters/ClientIdParam"
          }
        ],
        "responses": {
          "200": {
            "$ref": "#/components/responses/Ok"
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "500": {
            "$ref": "#/components/responses/ServerError"
          }
        }
      }
    },
    "/v2/databases": {
      "get": {
        "tags": [
          "Database Operations"
        ],
        "summary": "Returns a list of databases",
        "description": "Get a list of databases visible to the user",
        "security": [
          {
            "BearerAuth": [
              "org-db-view"
            ]
          }
        ],
        "operationId": "listDatabases",
        "parameters": [
          {
            "in": "query",
            "name": "include",
            "description": "Allows filtering so that databases in listed states are returned",
            "required": false,
            "schema": {
              "type": "string",
              "enum": [
                "nonterminated",
                "all",
                "active",
                "pending",
                "preparing",
                "prepared",
                "initializing",
                "parked",
                "parking",
                "unparking",
                "terminating",
                "terminated",
                "resizing",
                "error",
                "maintenance",
                "suspended",
                "suspending"
              ],
              "default": "nonterminated"
            }
          },
          {
            "in": "query",
            "name": "provider",
            "description": "Allows filtering so that databases from a given provider are returned",
            "required": false,
            "schema": {
              "type": "string",
              "enum": [
                "ALL",
                "GCP",
                "AWS",
                "AZURE"
              ],
              "default": "ALL"
            }
          },
          {
            "in": "query",
            "name": "starting_after",
            "schema": {
              "type": "string"
            },
            "required": false,
            "description": "Optional parameter for pagination purposes. Used as this value for starting retrieving a specific page of results"
          },
          {
            "in": "query",
            "name": "limit",
            "schema": {
              "type": "integer",
              "default": 25,
              "minimum": 1,
              "maximum": 100
            },
            "required": false,
            "description": "Optional parameter for pagination purposes. Specify the number of items for one page of data"
          }
        ],
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/Database"
                  }
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "5XX": {
            "$ref": "#/components/responses/ServerError"
          }
        }
      },
      "post": {
        "tags": [
          "Database Operations"
        ],
        "summary": "Create a new database",
        "description": "Takes a user provided databaseInfo and returns the uuid for a new database",
        "security": [
          {
            "BearerAuth": [
              "org-db-create"
            ]
          }
        ],
        "operationId": "createDatabase",
        "requestBody": {
          "description": "Definition of new database",
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/DatabaseInfoCreate"
              }
            }
          }
        },
        "responses": {
          "201": {
            "description": "created",
            "headers": {
              "Location": {
                "schema": {
                  "type": "string",
                  "description": "Database UUID"
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "422": {
            "$ref": "#/components/responses/UnprocessableEntity"
          },
          "500": {
            "$ref": "#/components/responses/ServerError"
          }
        }
      }
    },
    "/v2/databases/{databaseID}": {
      "get": {
        "tags": [
          "Database Operations"
        ],
        "summary": "Finds database by ID",
        "description": "Returns specified database",
        "security": [
          {
            "BearerAuth": [
              "org-db-view"
            ]
          }
        ],
        "operationId": "getDatabase",
        "parameters": [
          {
            "$ref": "#/components/parameters/DatabaseIdParam"
          }
        ],
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Database"
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "5XX": {
            "$ref": "#/components/responses/ServerError"
          }
        }
      }
    },
    "/v2/databases/{databaseID}/keyspaces/{keyspaceName}": {
      "post": {
        "tags": [
          "Database Operations"
        ],
        "summary": "Adds keyspace into database",
        "description": "Adds the specified keyspace to the database",
        "security": [
          {
            "BearerAuth": [
              "db-keyspace-create"
            ]
          }
        ],
        "operationId": "addKeyspace",
        "parameters": [
          {
            "$ref": "#/components/parameters/DatabaseIdParam"
          },
          {
            "$ref": "#/components/parameters/KeyspaceNameParam"
          }
        ],
        "responses": {
          "201": {
            "description": "created"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          },
          "422": {
            "$ref": "#/components/responses/UnprocessableEntity"
          },
          "5XX": {
            "$ref": "#/components/responses/ServerError"
          }
        }
      },
      "delete": {
        "tags": [
          "Database Operations"
        ],
        "description": "Removes the specified keyspace from the database",
        "operationId": "removeKeyspace",
        "parameters": [
          {
            "description": "String representation of the database ID",
            "explode": false,
            "in": "path",
            "name": "databaseID",
            "required": true,
            "schema": {
              "type": "string"
            },
            "style": "simple"
          },
          {
            "description": "Name of database keyspace",
            "explode": false,
            "in": "path",
            "name": "keyspaceName",
            "required": true,
            "schema": {
              "type": "string"
            },
            "style": "simple"
          }
        ],
        "responses": {
          "204": {
            "description": "successful operation"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Errors"
                }
              }
            },
            "description": "Bad request"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Errors"
                }
              }
            },
            "description": "The user is unauthorized to perform the operation"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Errors"
                }
              }
            },
            "description": "The specified database was not found"
          },
          "5XX": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Errors"
                }
              }
            },
            "description": "A server error occurred"
          }
        },
        "summary": "Removes keyspace"
      }
    },
    "/v2/databases/{databaseID}/keyspaces/{keyspaceName}/actions/alterWithGraphEngine": {
      "post": {
        "tags": [
          "Database Operations"
        ],
        "summary": "Alter keyspace to enable graph engine",
        "description": "Alter the specified keyspace to enable graph engine capabilities. Only supports Managed Cluster (Classic) databases.",
        "operationId": "alterKeyspaceWithGraphEngine",
        "parameters": [
          {
            "$ref": "#/components/parameters/DatabaseIdParam"
          },
          {
            "$ref": "#/components/parameters/KeyspaceNameParam"
          }
        ],
        "responses": {
          "202": {
            "description": "keyspace has been well updated with graph engine capabilities."
          },
          "204": {
            "description": "keyspace doesn't exists."
          },
          "400": {
            "description": "Not a valid E Tier."
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "500": {
            "$ref": "#/components/responses/ServerError"
          }
        }
      }
    },
    "/v2/databases/{databaseID}/secureBundleURL": {
      "post": {
        "summary": "Obtain zip for connecting to the database",
        "description": "Returns a temporary URL to download a zip file with certificates for connecting to the database. The URL expires after five minutes.<p>There are two types of the secure bundle URL: <ul><li><b>Internal</b> - Use with VPC peering connections to use private networking and avoid public internet for communication.</li> <li><b>External</b> - Use with any connection where the public internet is sufficient for communication between the application and the Astra database with MTLS.</li></ul> Both types support MTLS for communication via the driver.</p>",
        "security": [
          {
            "BearerAuth": [
              "db-cql"
            ]
          }
        ],
        "operationId": "generateSecureBundleURL",
        "tags": [
          "Database Operations"
        ],
        "parameters": [
          {
            "$ref": "#/components/parameters/DatabaseIdParam"
          },
          {
            "$ref": "#/components/parameters/AllDatacentersParam"
          }
        ],
        "responses": {
          "200": {
            "description": "Credentials provides a link to download cluster secure-connect-*.zip file",
            "content": {
              "application/json": {
                "schema": {
                  "oneOf": [
                    {
                      "$ref": "#/components/schemas/CredsURL"
                    },
                    {
                      "$ref": "#/components/schemas/CredsURLList"
                    }
                  ]
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          },
          "5XX": {
            "$ref": "#/components/responses/ServerError"
          }
        }
      }
    },
    "/v2/databases/{databaseID}/telemetry/metrics": {
      "post": {
        "summary": "Configure Astra Remote Telemetry",
        "description": "Enables metrics exporting to an external system. Note: updates replace any existing config.",
        "security": [
          {
            "BearerAuth": [
              "telemetry"
            ]
          }
        ],
        "operationId": "configureTelemetry",
        "parameters": [
          {
            "$ref": "#/components/parameters/DatabaseIdParam"
          }
        ],
        "tags": [
          "Database Operations"
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "anyOf": [
                  {
                    "$ref": "#/components/schemas/KafkaTelemetryRequest"
                  },
                  {
                    "$ref": "#/components/schemas/RemotePrometheusTelemetryRequest"
                  },
                  {
                    "$ref": "#/components/schemas/CloudWatchTelemetryRequest"
                  },
                  {
                    "$ref": "#/components/schemas/SplunkTelemetryRequest"
                  },
                  {
                    "$ref": "#/components/schemas/PulsarTelemetryRequest"
                  },
                  {
                    "$ref": "#/components/schemas/DatadogTelemetryRequest"
                  }
                ]
              }
            }
          }
        },
        "responses": {
          "202": {
            "$ref": "#/components/responses/Accepted"
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          },
          "5XX": {
            "$ref": "#/components/responses/ServerError"
          }
        }
      },
      "get": {
        "summary": "Retrieve Remote Telemetry configuration",
        "description": "Get the current Telemetry configuration for the database",
        "operationId": "getTelemetryConfig",
        "tags": [
          "Database Operations"
        ],
        "parameters": [
          {
            "$ref": "#/components/parameters/DatabaseIdParam"
          }
        ],
        "responses": {
          "200": {
            "description": "The current stored Remote Telemetry configuration for this database",
            "content": {
              "application/json": {
                "schema": {
                  "anyOf": [
                    {
                      "$ref": "#/components/schemas/KafkaTelemetryRequest"
                    },
                    {
                      "$ref": "#/components/schemas/RemotePrometheusTelemetryRequest"
                    },
                    {
                      "$ref": "#/components/schemas/CloudWatchTelemetryRequest"
                    },
                    {
                      "$ref": "#/components/schemas/SplunkTelemetryRequest"
                    },
                    {
                      "$ref": "#/components/schemas/PulsarTelemetryRequest"
                    },
                    {
                      "$ref": "#/components/schemas/DatadogTelemetryRequest"
                    }
                  ]
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          },
          "5XX": {
            "$ref": "#/components/responses/ServerError"
          }
        }
      }
    },
    "/v2/databases/{databaseID}/terminate": {
      "post": {
        "summary": "Terminates a database",
        "description": "Terminates a database",
        "security": [
          {
            "BearerAuth": [
              "org-db-terminate"
            ]
          }
        ],
        "operationId": "terminateDatabase",
        "tags": [
          "Database Operations"
        ],
        "parameters": [
          {
            "$ref": "#/components/parameters/DatabaseIdParam"
          },
          {
            "in": "query",
            "name": "preparedStateOnly",
            "description": "For internal use only.  Used to safely terminate prepared databases.",
            "required": false,
            "schema": {
              "type": "boolean",
              "default": false
            }
          }
        ],
        "responses": {
          "202": {
            "$ref": "#/components/responses/Accepted"
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          },
          "5XX": {
            "$ref": "#/components/responses/ServerError"
          }
        }
      }
    },
    "/v2/databases/{databaseID}/resize": {
      "post": {
        "summary": "Resizes a database",
        "description": "Resizes a Managed Cluster (Classic) database, specifying the desired total number of capacity units. This operation isn't applicable to Astra DB Serverless databases, and it has no relationship to Provisioned Capacity Units for Astra DB Serverless.",
        "security": [
          {
            "BearerAuth": [
              "org-db-expand"
            ]
          }
        ],
        "operationId": "resizeDatabase",
        "tags": [
          "Database Operations"
        ],
        "parameters": [
          {
            "$ref": "#/components/parameters/DatabaseIdParam"
          }
        ],
        "requestBody": {
          "description": "Map containing the capacityUnits key and a value greater than the current number of capacity units. You can increase the number of CUs by no more than 3 units per operation.",
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CapacityUnits"
              }
            }
          }
        },
        "responses": {
          "202": {
            "$ref": "#/components/responses/Accepted"
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          },
          "5XX": {
            "$ref": "#/components/responses/ServerError"
          }
        }
      }
    },
    "/v2/databases/{databaseID}/datacenters": {
      "get": {
        "summary": "List all database datacenters",
        "description": "Returns the list of configured ACTIVE datacenters for the given database, if you want to get the TERMINATED along with ACTIVE send query param all=true",
        "operationId": "listDatacenters",
        "tags": [
          "Database Operations"
        ],
        "parameters": [
          {
            "$ref": "#/components/parameters/DatabaseIdParam"
          },
          {
            "in": "query",
            "name": "all",
            "description": "Allows retrieving datacenters in TERMINATED state along with ACTIVE ones",
            "required": false,
            "schema": {
              "type": "boolean",
              "default": false
            }
          }
        ],
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/Datacenter"
                  }
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "5XX": {
            "$ref": "#/components/responses/ServerError"
          }
        }
      },
      "post": {
        "summary": "Adds datacenters",
        "description": "Deploy a multi-region database to an additional AWS, Azure, or Google Cloud datacenter.",
        "operationId": "addDatacenters",
        "tags": [
          "Database Operations"
        ],
        "parameters": [
          {
            "$ref": "#/components/parameters/DatabaseIdParam"
          }
        ],
        "requestBody": {
          "description": "List of values necessary to add the datacenter. Can be used to add multiple datacenters at once.",
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "array",
                "items": {
                  "$ref": "#/components/schemas/Datacenter"
                }
              }
            }
          }
        },
        "responses": {
          "201": {
            "$ref": "#/components/responses/Accepted"
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "5XX": {
            "$ref": "#/components/responses/ServerError"
          }
        }
      }
    },
    "/v2/databases/{databaseID}/datacenters/{datacenterID}/terminate": {
      "post": {
        "summary": "Terminates a datacenter",
        "description": "Terminates a datacenter",
        "operationId": "terminateDatacenter",
        "tags": [
          "Database Operations"
        ],
        "parameters": [
          {
            "$ref": "#/components/parameters/DatabaseIdParam"
          },
          {
            "$ref": "#/components/parameters/DatacenterIdParam"
          }
        ],
        "responses": {
          "202": {
            "$ref": "#/components/responses/Accepted"
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          },
          "5XX": {
            "$ref": "#/components/responses/ServerError"
          }
        }
      }
    },
    "/v2/databases/{databaseID}/resetPassword": {
      "post": {
        "summary": "Resets Password",
        "description": "Sets a database password to the one specified in POST body",
   

# --- truncated at 32 KB (304 KB total) ---
# Full source: https://raw.githubusercontent.com/api-evangelist/datastax/refs/heads/main/openapi/datastax-devops-openapi.json
Astra DevOps API

Documentation

Specifications

Other Resources

OpenAPI Specification
