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

# Get

> Get the details of a reserved domain.




## OpenAPI

````yaml https://raw.githubusercontent.com/ngrok/ngrok-openapi/refs/heads/main/ngrok.yaml get /reserved_domains/{id}
openapi: 3.0.0
info:
  title: ngrok OpenAPI
  version: 1.0.0
  description: >
    The ngrok REST API at https://api.ngrok.com provides programmatic access to
    provision and configure every ngrok resource: endpoints, domains, API keys,
    IP policies, tunnels, certificates, and more. Full documentation:
    https://ngrok.com/docs/api


    **Authentication:** Send an API key as a bearer token: "Authorization:
    Bearer {API key}". Create and revoke keys at
    https://dashboard.ngrok.com/api-keys or via the /api_keys resource. Requests
    without credentials receive an error with code ERR_NGROK_200.


    **Versioning and deprecation policy:** Every request must include the
    "ngrok-version: 2" header; a missing header returns HTTP 400 with error code
    ERR_NGROK_218. Version 2 is the current version; all earlier versions are
    deprecated. ngrok never makes breaking changes to a published API version.
    Breaking changes ship only as a new version that clients explicitly opt in
    to via this header. Additive changes (new resources, methods, and fields,
    and bug fixes that match documented behavior) may ship to a live version.
    Full policy: https://ngrok.com/docs/api#versioning-and-api-stability


    **Rate limits:** By default, the API allows 120 requests per rolling
    60-second window per account; some plans have higher limits. Exceeding the
    limit returns HTTP 429 with error code ERR_NGROK_226; wait for the window to
    pass before retrying. Details: https://ngrok.com/docs/errors/err_ngrok_226


    **Errors:** Every 4xx and 5xx response carries the Error schema: the
    status_code, a human-readable msg, and in most cases a globally unique
    machine-readable error_code and a details object. Every error code is
    documented at https://ngrok.com/docs/errors
servers:
  - url: https://api.ngrok.com
security:
  - authentication: []
paths:
  /reserved_domains/{id}:
    get:
      tags:
        - ReservedDomains
      summary: Get
      description: |
        Get the details of a reserved domain.
      operationId: ReservedDomainsGet
      parameters:
        - $ref: '#/components/parameters/ngrokVersion'
        - name: id
          description: |
            a resource identifier
          in: path
          required: true
          schema:
            type: string
      responses:
        '200':
          description: |
            Get the details of a reserved domain.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ReservedDomain'
        4XX:
          $ref: '#/components/responses/Error'
        5XX:
          $ref: '#/components/responses/Error'
components:
  parameters:
    ngrokVersion:
      name: ngrok-version
      in: header
      required: true
      schema:
        type: integer
        default: 2
  schemas:
    ReservedDomain:
      type: object
      properties:
        id:
          description: |
            unique reserved domain resource identifier
          type: string
        uri:
          description: |
            URI of the reserved domain API resource
          type: string
        created_at:
          description: |
            timestamp when the reserved domain was created, RFC 3339 format
          type: string
        description:
          description: >
            human-readable description of what this reserved domain will be used
            for
          type: string
        metadata:
          description: >
            arbitrary user-defined machine-readable data of this reserved
            domain. Optional, max 4096 bytes.
          type: string
        domain:
          description: |
            hostname of the reserved domain
          type: string
        region:
          description: >
            deprecated: With the launch of the ngrok Global Network domains
            traffic is now handled globally. This field applied only to
            endpoints. Note that agents may still connect to specific regions.
            Optional, null by default. (`au`, `eu`, `ap`, `us`, `jp`, `in`,
            `sa`)
          type: string
        cname_target:
          description: >
            DNS CNAME target for a custom hostname, or null if the reserved
            domain is a subdomain of an ngrok owned domain (for example,
            *.ngrok.app)
          type: string
        certificate:
          $ref: '#/components/schemas/Ref'
          description: >
            object referencing the TLS certificate used for connections to this
            domain. This can be either a user-uploaded certificate, the most
            recently issued automatic one, or null otherwise.
        certificate_management_policy:
          $ref: '#/components/schemas/ReservedDomainCertPolicy'
          description: >
            configuration for automatic management of TLS certificates for this
            domain, or null if automatic management is disabled
        certificate_management_status:
          $ref: '#/components/schemas/ReservedDomainCertStatus'
          description: >
            status of the automatic certificate management for this domain, or
            null if automatic management is disabled
        acme_challenge_cname_target:
          description: >
            DNS CNAME target for the host _acme-challenge.example.com, where
            example.com is your reserved domain name. This is required to issue
            certificates for wildcard, non-ngrok reserved domains. Must be null
            for non-wildcard domains and ngrok subdomains.
          type: string
        resolves_to:
          description: |
            Region and IP resolution targets configured for the Domain.
          type: array
          items:
            $ref: '#/components/schemas/ReservedDomainResolvesToEntry'
    Ref:
      type: object
      properties:
        id:
          description: |
            a resource identifier
          type: string
        uri:
          description: |
            a uri for locating a resource
          type: string
    ReservedDomainCertPolicy:
      type: object
      properties:
        authority:
          description: >
            certificate authority to request certificates from. The only
            supported value is letsencrypt.
          type: string
        private_key_type:
          description: >
            type of private key to use when requesting certificates. Defaults to
            ecdsa, can be either rsa or ecdsa.
          type: string
    ReservedDomainCertStatus:
      type: object
      properties:
        renews_at:
          description: |
            timestamp when the next renewal will be requested, RFC 3339 format
          type: string
        provisioning_job:
          $ref: '#/components/schemas/ReservedDomainCertJob'
          description: >
            status of the certificate provisioning job, or null if the
            certificiate isn't being provisioned or renewed
    ReservedDomainResolvesToEntry:
      type: object
      properties:
        value:
          description: |
            accepts an ngrok point-of-presence shortcode, or "global"
          type: string
    Error:
      type: object
      description: >
        The error body every api.ngrok.com 4xx and 5xx response returns. Every
        error condition has a globally unique, documented error code; see
        https://ngrok.com/docs/errors
      required:
        - status_code
        - msg
      properties:
        error_code:
          description: >
            Globally unique machine-readable error code, for example
            ERR_NGROK_226. Each code is documented at
            https://ngrok.com/docs/errors/reference. Omitted on transport-level
            errors such as a plain 404 for an unknown path.
          type: string
        status_code:
          description: |
            The HTTP status code of the response, duplicated in the body.
          type: integer
        msg:
          description: |
            Human-readable description of the error and how to resolve it.
          type: string
        details:
          description: >
            Additional error context. details.operation_id identifies the failed
            request when contacting support.
          type: object
          additionalProperties:
            type: string
    ReservedDomainCertJob:
      type: object
      properties:
        error_code:
          description: >
            if present, an error code indicating why provisioning is failing. It
            may be either a temporary condition (INTERNAL_ERROR), or a permanent
            one the user must correct (DNS_ERROR).
          type: string
        msg:
          description: |
            a message describing the current status or error
          type: string
        started_at:
          description: |
            timestamp when the provisioning job started, RFC 3339 format
          type: string
        retries_at:
          description: |
            timestamp when the provisioning job will be retried
          type: string
  responses:
    Error:
      description: >
        An error. The body carries a machine-readable error_code and a
        human-readable msg; every code is documented at
        https://ngrok.com/docs/errors. A 429 with error code ERR_NGROK_226 means
        the account exceeded the documented request-rate limit.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
  securitySchemes:
    authentication:
      type: http
      scheme: bearer

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.