> ## Documentation Index
> Fetch the complete documentation index at: https://cockroachlabs.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# View a restore job

> Can be used by the following roles assigned at the organization, folder or cluster scope:
- CLUSTER_ADMIN
- CLUSTER_OPERATOR_WRITER




## OpenAPI

````yaml /openapi/cloud/latest.json get /api/v1/clusters/{cluster_id}/restores/{restore_id}
openapi: 3.0.0
info:
  contact:
    email: support@cockroachlabs.com
    name: Cockroach Labs Support
    url: https://support.cockroachlabs.com
  description: An API for managing CockroachDB Cloud resources
  title: CockroachDB Cloud API
  version: '2024-09-16'
servers:
  - url: https://cockroachlabs.cloud
security:
  - Bearer: []
tags:
  - name: SCIM
  - name: Organizations
  - name: Clusters
  - name: Cluster Disruption
  - name: SQL Users
  - name: SQL Privilege Grants
  - name: Databases
  - name: Customer-managed Encryption Keys
  - name: Client CA Certificates
  - name: Cluster SSO
  - name: Log Export
  - name: Metric Export
  - name: Audit Logs
  - name: IP Allowlists
  - name: Egress Rules
  - name: Billing
  - name: Maintenance Windows
  - name: Blackout Windows
  - name: Role Management
  - name: Service Accounts
  - name: API Keys
  - name: Folders
  - name: Version Deferral
  - name: JWT Issuers
  - name: OpenID Connect Configuration
  - name: Private Endpoint Services
  - name: PCI
  - name: Physical Cluster Replication
  - name: Plan Migrations
  - name: Backup/Restore
  - name: Egress Private Endpoints
  - name: Multifactor Authentication
externalDocs:
  description: Use the CockroachDB Cloud API
  url: https://www.cockroachlabs.com/docs/cockroachcloud/cloud-api.html
paths:
  /api/v1/clusters/{cluster_id}/restores/{restore_id}:
    get:
      tags:
        - Backup/Restore
      summary: View a restore job
      description: >
        Can be used by the following roles assigned at the organization, folder
        or cluster scope:

        - CLUSTER_ADMIN

        - CLUSTER_OPERATOR_WRITER
      operationId: CockroachCloud_GetRestore
      parameters:
        - name: cluster_id
          in: path
          description: The ID of the cluster where the restore ran or is currently running.
          required: true
          schema:
            type: string
        - name: restore_id
          in: path
          description: The ID of the restore.
          required: true
          schema:
            type: string
      responses:
        '200':
          description: A successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Restore'
        '400':
          description: Returned when a request field is invalid.
          content:
            application/json:
              schema: {}
        '401':
          description: Returned when the token bearer cannot be authenticated.
          content:
            application/json:
              schema: {}
        '403':
          description: >-
            Returned when the user does not have permission to access the
            resource.
          content:
            application/json:
              schema: {}
        '404':
          description: Returned when the resource does not exist.
          content:
            application/json:
              schema: {}
        '500':
          description: Server error
          content:
            application/json:
              schema: {}
        default:
          description: An unexpected error response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Status'
      x-codeSamples:
        - lang: Shell + Curl
          source: |-
            curl --request GET \
              --url https://cockroachlabs.cloud/api/v1/clusters/{cluster_id}/restores/{restore_id} \
              --header 'Authorization: Bearer REPLACE_BEARER_TOKEN'
components:
  schemas:
    Restore:
      type: object
      properties:
        backup_end_time:
          description: The timestamp at which the backup data was captured.
          type: string
          format: date-time
        backup_id:
          description: The ID of the backup used for this restore job.
          type: string
        client_error_code:
          description: Error code from the restore job, only populated if it has failed.
          type: integer
          format: int32
        client_error_message:
          description: Error message from the restore job, only populated if it has failed.
          type: string
        completed_at:
          description: The timestamp at which the restore job completed.
          type: string
          format: date-time
        completion_percent:
          description: |-
            The percentage of the restore job that has been completed.
            The value ranges from 0 to 1.
          type: number
          format: float
        crdb_job_id:
          description: The CockroachDB internal job ID for the restore job.
          type: string
        created_at:
          description: The time at which the restore job was initiated.
          type: string
          format: date-time
        destination_cluster_name:
          description: The name of the cluster to which the restore is being applied.
          type: string
        id:
          description: The unique identifier associated with the restore.
          type: string
        objects:
          description: The list of database objects (databases, tables) that were restored.
          type: array
          items:
            $ref: '#/components/schemas/RestoreItem'
        restore_opts:
          $ref: '#/components/schemas/RestoreOpts'
        source_cluster_name:
          description: The name of the cluster from which the backup was taken.
          type: string
        status:
          $ref: '#/components/schemas/RestoreStatus.Type'
        type:
          $ref: '#/components/schemas/RestoreType.Type'
      example:
        backup_end_time: '2025-07-09T14:00:00Z'
        backup_id: 1234abcd-1234-1234-abcd-12345678abcd
        completion_percent: 0
        created_at: '2025-07-09T15:04:05Z'
        destination_cluster_name: dest-cluster
        id: abcd1234-5678-90ab-cdef-1234567890ab
        objects:
          - database: mydb
            schema: public
            table: users
        source_cluster_name: src-cluster
        status: PENDING
        type: TABLE
      required:
        - id
        - backup_id
        - status
        - created_at
        - type
        - completion_percent
        - source_cluster_name
        - destination_cluster_name
        - backup_end_time
    Status:
      type: object
      properties:
        code:
          format: int32
          type: integer
        details:
          type: array
          items:
            $ref: '#/components/schemas/Any'
        message:
          type: string
    RestoreItem:
      type: object
      properties:
        database:
          type: string
        schema:
          type: string
        table:
          type: string
      required:
        - database
    RestoreOpts:
      type: object
      properties:
        into_db:
          description: |-
            Specifies the target database to restore the table into during a
            table restore job. If not set, the table will be restored
            into the database it belonged to in the source backup.
          type: string
        new_db_name:
          description: |-
            Specifies the name of the database to create during a
            database restore job. If not set, the name defaults to
            the original database name from the source cluster.
          type: string
        schema_only:
          description: |-
            If set, only the schema will be restored and no user data will
            be included.
          type: boolean
        skip_localities_check:
          description: |-
            Allows the restore job to continue in the event that there
            are mismatched localities between the backup and target cluster.
            Useful when restoring multi-region tables to a cluster missing
            some localities.
          type: boolean
        skip_missing_foreign_keys:
          description: |-
            Allows a table to be restored even if it has foreign key
            constraints referencing rows that no longer exist in the target
            cluster.
          type: boolean
        skip_missing_sequences:
          type: boolean
          title: |-
            Allows a table to be restored even if it contains a column whose
            `DEFAULT` value depends on a sequence.
            (See https://www.cockroachlabs.com/docs/stable/show-sequences)
        skip_missing_views:
          description: |-
            Allows the job to skip restoring views that cannot be
            restored because their dependencies are not included in the
            current restore job.
          type: boolean
    RestoreStatus.Type:
      type: string
      enum:
        - PENDING
        - SUCCESS
        - FAILED
    RestoreType.Type:
      type: string
      enum:
        - CLUSTER
        - DATABASE
        - TABLE
    Any:
      description: >-
        `Any` contains an arbitrary serialized protocol buffer message along
        with a

        URL that describes the type of the serialized message.


        In its binary encoding, an `Any` is an ordinary message; but in other
        wire

        forms like JSON, it has a special encoding. The format of the type URL
        is

        described on the `type_url` field.


        Protobuf APIs provide utilities to interact with `Any` values:


        - A 'pack' operation accepts a message and constructs a generic `Any`
        wrapper
          around it.
        - An 'unpack' operation reads the content of an `Any` message, either
        into an
          existing message or a new one. Unpack operations must check the type of the
          value they unpack against the declared `type_url`.
        - An 'is' operation decides whether an `Any` contains a message of the
        given
          type, i.e. whether it can 'unpack' that type.

        The JSON format representation of an `Any` follows one of these cases:


        - For types without special-cased JSON encodings, the JSON format
          representation of the `Any` is the same as that of the message, with an
          additional `@type` field which contains the type URL.
        - For types with special-cased JSON encodings (typically called
        'well-known'
          types, listed in https://protobuf.dev/programming-guides/json/#any), the
          JSON format representation has a key `@type` which contains the type URL
          and a key `value` which contains the JSON-serialized value.

        The text format representation of an `Any` is like a message with one
        field

        whose name is the type URL in brackets. For example, an `Any` containing
        a

        `foo.Bar` message may be written `[type.googleapis.com/foo.Bar] { a: 2
        }`.
      type: object
      properties:
        '@type':
          description: >-
            Identifies the type of the serialized Protobuf message with a URI
            reference

            consisting of a prefix ending in a slash and the fully-qualified
            type name.


            Example: type.googleapis.com/google.protobuf.StringValue


            This string must contain at least one `/` character, and the content
            after

            the last `/` must be the fully-qualified name of the type in
            canonical

            form, without a leading dot. Do not write a scheme on these URI
            references

            so that clients do not attempt to contact them.


            The prefix is arbitrary and Protobuf implementations are expected to

            simply strip off everything up to and including the last `/` to
            identify

            the type. `type.googleapis.com/` is a common default prefix that
            some

            legacy implementations require. This prefix does not indicate the
            origin of

            the type, and URIs containing it are not expected to respond to any

            requests.


            All type URL strings must be legal URI references with the
            additional

            restriction (for the text format) that the content of the reference

            must consist only of alphanumeric characters, percent-encoded
            escapes, and

            characters in the following set (not including the outer backticks):

            `/-.~_!$&()*+,;=`. Despite our allowing percent encodings,
            implementations

            should not unescape them to prevent confusion with existing parsers.
            For

            example, `type.googleapis.com%2FFoo` should be rejected.


            In the original design of `Any`, the possibility of launching a type

            resolution service at these type URLs was considered but Protobuf
            never

            implemented one and considers contacting these URLs to be
            problematic and

            a potential security issue. Do not attempt to contact type URLs.
          type: string
      additionalProperties: {}
  securitySchemes:
    Bearer:
      type: http
      scheme: bearer

````