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

# List egress private endpoints

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


<Warning>This endpoint is in **Limited Access** and may not be available to all users. Refer to the [API support policy](https://www.cockroachlabs.com/docs/stable/api-support-policy) for more details.</Warning>


## OpenAPI

````yaml /openapi/cloud/latest.json get /api/v1/clusters/{cluster_id}/networking/egress-private-endpoints
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}/networking/egress-private-endpoints:
    get:
      tags:
        - Egress Private Endpoints
      summary: List egress private endpoints
      description: >
        Can be used by the following roles assigned at the organization, folder
        or cluster scope:

        - CLUSTER_ADMIN

        - CLUSTER_OPERATOR_WRITER
      operationId: CockroachCloud_ListEgressPrivateEndpoints
      parameters:
        - name: cluster_id
          in: path
          description: >-
            cluster_id identifies the CockroachDB Cloud cluster whose egress
            private endpoints to list.
          required: true
          schema:
            type: string
        - name: pagination.page
          in: query
          schema:
            type: string
        - name: pagination.limit
          in: query
          schema:
            format: int32
            type: integer
        - name: pagination.as_of_time
          in: query
          schema:
            type: string
            format: date-time
        - name: pagination.sort_order
          in: query
          description: |2-
             - ASC: Sort in ascending order. This is the default unless otherwise specified.
             - DESC: Sort in descending order.
          schema:
            type: string
            enum:
              - ASC
              - DESC
      responses:
        '200':
          description: A successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListEgressPrivateEndpointsResponse'
        '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: curl
          source: |-
            curl --request GET \
              --url 'https://cockroachlabs.cloud/api/v1/clusters/{cluster_id}/networking/egress-private-endpoints?pagination.page=SOME_STRING_VALUE&pagination.limit=SOME_INTEGER_VALUE&pagination.as_of_time=SOME_STRING_VALUE&pagination.sort_order=SOME_STRING_VALUE' \
              --header 'Authorization: Bearer REPLACE_BEARER_TOKEN'
components:
  schemas:
    ListEgressPrivateEndpointsResponse:
      type: object
      properties:
        egress_private_endpoints:
          description: >-
            egress_private_endpoints are the egress private endpoints associated
            with the given cluster.
          type: array
          items:
            $ref: '#/components/schemas/EgressPrivateEndpoint'
        pagination:
          $ref: '#/components/schemas/KeysetPaginationResponse'
      required:
        - egress_private_endpoints
      title: ListEgressPrivateEndpointsResponse
    Status:
      type: object
      properties:
        code:
          format: int32
          type: integer
        details:
          type: array
          items:
            $ref: '#/components/schemas/Any'
        message:
          type: string
    EgressPrivateEndpoint:
      type: object
      properties:
        domain_names:
          description: >-
            domain_names are the domain names associated with the egress private
            endpoint.
          type: array
          items:
            type: string
        domain_names_state:
          $ref: '#/components/schemas/EgressPrivateEndpointDomainNamesState.Type'
        endpoint_address:
          type: string
          title: |-
            endpoint_address is the cloud-provider generated address (either
            IP address or DNS name) through which the endpoint is accessible
        endpoint_connection_id:
          description: >-
            endpoint_connection_id is the cloud-specific id for egress private
            endpoints.

            This connection ID is visible in CRL and CSP consoles as "VPC
            endpoint ID" and

            is used to uniquely identify the endpoint in external
            configurations.
          type: string
        id:
          description: >-
            A generated ID that uniquely identifies the egress_private_endpoint

            for use with the CockroachDB Cloud API. This ID is generic and not
            specific

            to the cloud provider.
          type: string
        region:
          description: region represents the cloud region that the endpoint was created in.
          type: string
        state:
          $ref: '#/components/schemas/EgressPrivateEndpointState.Type'
        target_service_identifier:
          description: >-
            target_service_identifier represents the identifier of the target
            service.

            User-visible in CRL and CSP consoles as the "thing" the user is
            telling us to connect to,

            i.e. Service Name for AWS, Service Attachment for GCP, or ARN for
            AWS MSK.
          type: string
        target_service_type:
          $ref: '#/components/schemas/EgressPrivateEndpointTargetServiceType.Type'
      required:
        - id
        - endpoint_connection_id
        - region
        - target_service_identifier
        - target_service_type
        - endpoint_address
        - state
        - domain_names
      title: EgressPrivateEndpoint
    KeysetPaginationResponse:
      type: object
      properties:
        next_page:
          type: string
        previous_page:
          type: string
    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: {}
    EgressPrivateEndpointDomainNamesState.Type:
      type: string
      enum:
        - EMPTY
        - PENDING
        - AVAILABLE
        - FAILED
      title: >-
        - EMPTY: EMPTY indicates that there are no egress private endpoint
        domain names on the cluster
         - PENDING: PENDING indicates that the domain names are currently being applied on the cluster
         - AVAILABLE: AVAILABLE indicates that the domain names have been applied on the cluster
         - FAILED: FAILED indicates that the domain names have failed to apply on the cluster
    EgressPrivateEndpointState.Type:
      type: string
      enum:
        - PENDING
        - PENDING_ACCEPTANCE
        - AVAILABLE
        - DELETING
        - DELETED
        - REJECTED
        - FAILED
        - EXPIRED
    EgressPrivateEndpointTargetServiceType.Type:
      type: string
      enum:
        - PRIVATE_SERVICE
        - MSK_SASL_SCRAM
        - MSK_SASL_IAM
        - MSK_TLS
      title: >-
        - PRIVATE_SERVICE: PRIVATE_SERVICE represents any private service, such
        as a GCP service attachment, or an AWS VPC endpoint service.
         - MSK_SASL_SCRAM: MSK_SASL_SCRAM represents the managed Kafka service in AWS, with SASL/SCRAM auth
         - MSK_SASL_IAM: MSK_SASL_IAM represents the managed Kafka service in AWS, with SASL/IAM auth
         - MSK_TLS: MSK_TLS represents the managed Kafka service in AWS, with TLS auth
  securitySchemes:
    Bearer:
      type: http
      scheme: bearer

````