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

# Get Custom Domains

> Read the service's active and pending custom domain, each hydrated with live DNS records.

Note that `data.custom_domain` holds a pair object, not a single domain and not an array.



## OpenAPI

````yaml /openapi.json get /v1/environments/{envId}/services/{serviceId}/custom-domains
openapi: 3.0.0
info:
  title: LocalOps API
  version: 1.0.0
  description: >-
    API for programmatically managing LocalOps environments and services.


    Every successful response (except `GET /health` and `DELETE
    /v1/environments/{envId}/services/{serviceId}`) is wrapped in an envelope:
    `{ "message": "success", "data": { ... } }`. Errors are returned unwrapped
    as `{ "error_code": "...", "message": "...", "errors": [...] }`.


    Deploys, deletes, secret writes and custom domain deploys are asynchronous.
    A 2xx confirms that the request was accepted and passed synchronous
    validation - observe the outcome by polling deployment state, service state
    or custom domain state.


    Endpoints badged **COMING SOON** are not live yet. Their request and
    response shapes are published so you can plan an integration, and may change
    before release - calls to those paths return `404` today.
servers:
  - url: https://sdk.localops.co
security:
  - bearerAuth: []
tags:
  - name: Health
    description: Liveness probe.
  - name: Environments
    description: Read an environment's identity, network edges and workload identity.
  - name: Services
    description: Create, read, update and delete services inside an environment.
  - name: Deployments
    description: Trigger deployments and poll their state.
  - name: Operations
    description: Track asynchronous work, with per operation status, error and logs.
  - name: Custom Domains
    description: Attach and verify custom domains for a service.
  - name: Secrets
    description: Read and replace environment level and service level secrets.
paths:
  /v1/environments/{envId}/services/{serviceId}/custom-domains:
    get:
      tags:
        - Custom Domains
      summary: Get Custom Domains
      description: >-
        Read the service's active and pending custom domain, each hydrated with
        live DNS records.


        Note that `data.custom_domain` holds a pair object, not a single domain
        and not an array.
      operationId: getCustomDomains
      parameters:
        - name: envId
          in: path
          required: true
          description: The unique identifier of the environment
          schema:
            type: string
            format: uuid
        - name: serviceId
          in: path
          required: true
          description: The unique identifier of the service
          schema:
            type: string
            format: uuid
      responses:
        '200':
          description: Active and pending custom domains
          content:
            application/json:
              schema:
                type: object
                properties:
                  message:
                    type: string
                  data:
                    type: object
                    properties:
                      custom_domain:
                        type: object
                        properties:
                          is_active:
                            type: boolean
                            description: The service has a custom domain attached
                          is_pending:
                            type: boolean
                            description: >-
                              A newer domain exists that is not yet the active
                              one
                          active_domain:
                            type: object
                            nullable: true
                            allOf:
                              - $ref: '#/components/schemas/CustomDomain'
                            description: Currently serving domain
                          pending_domain:
                            type: object
                            nullable: true
                            allOf:
                              - $ref: '#/components/schemas/CustomDomain'
                            description: Domain awaiting verification or deployment
              example:
                message: success
                data:
                  custom_domain:
                    is_active: true
                    is_pending: false
                    active_domain:
                      id: d41f5b60-0000-0000-0000-000000000000
                      domain: app.example.com
                      state: deployed
                      dns_records: []
                    pending_domain: null
        '401':
          $ref: '#/components/responses/Unauthorized'
        '404':
          $ref: '#/components/responses/NotFound'
        '422':
          $ref: '#/components/responses/ValidationError'
        '500':
          $ref: '#/components/responses/ServerError'
components:
  schemas:
    CustomDomain:
      type: object
      properties:
        id:
          type: string
          format: uuid
        account_id:
          type: string
          format: uuid
        private_instance_id:
          type: string
          format: uuid
        service_id:
          type: string
          format: uuid
        prov_custom_domain_id:
          type: string
        domain:
          type: string
        origin:
          type: string
        state:
          type: string
          enum:
            - unverified
            - verified
            - deploy_queued
            - deploying
            - deployed
            - deploy_failed
            - delete_queued
            - deleting
            - deleted
            - delete_failed
        dns_records:
          type: array
          description: >-
            Hydrated live from the provisioner. Present on add, verify and list
            responses.
          items:
            $ref: '#/components/schemas/DnsRecord'
        created_at:
          type: string
          format: date-time
        updated_at:
          type: string
          format: date-time
    DnsRecord:
      type: object
      properties:
        purpose:
          type: string
          enum:
            - route_app_traffic
            - route_monit_traffic
            - verify_acm
        record_name:
          type: string
          description: DNS name to create
        record_type:
          type: string
          description: DNS record type, for example `CNAME`
        record_value:
          type: string
          description: DNS record value
        created_at:
          type: string
          format: date-time
    Error:
      type: object
      properties:
        error_code:
          type: string
          enum:
            - unauthorized
            - forbidden
            - notfound
            - conflict
            - validation
            - unknown
          description: >-
            Machine readable error code. Treat this, and not the HTTP status, as
            the signal for whether the request was at fault - some business rule
            violations are returned as `500` with `error_code: validation`.
        message:
          type: string
          description: Human readable error message
        errors:
          type: array
          nullable: true
          description: >-
            Per field details. Present only on validation errors, and can be
            null when the failure has no field level detail.
          items:
            $ref: '#/components/schemas/FieldError'
    FieldError:
      type: object
      properties:
        field:
          type: string
          description: Name of the request field that failed validation
        error:
          type: string
          description: Reason the field was rejected
  responses:
    Unauthorized:
      description: Missing, malformed or unknown API token
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error_code: unauthorized
            message: You are not authorized to do this action
    NotFound:
      description: >-
        The environment, service, deployment, custom domain or connection does
        not exist, or belongs to another account
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error_code: notfound
            message: Service not found
    ValidationError:
      description: >-
        Field validation failed, or the request body was missing or malformed.
        Endpoints that take a body always need at least `{}` - a zero byte body
        fails to bind.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          examples:
            field:
              summary: Field validation
              value:
                error_code: validation
                message: Invalid data
                errors:
                  - field: replica_count
                    error: replica_count is a required field
            body:
              summary: Missing or malformed body
              value:
                error_code: validation
                message: Please check your request body
    ServerError:
      description: >-
        Unexpected failure. Some business rule violations are also returned here
        with `error_code: validation` - check `error_code` rather than the
        status to decide whether the request was at fault.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          examples:
            unknown:
              summary: Unexpected failure
              value:
                error_code: unknown
                message: Something went wrong. Please try again later
            rule:
              summary: Business rule violation
              value:
                error_code: validation
                message: Ops Json is only supported for docker image source
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: UUID
      description: >-
        Your account API token, sent as `Authorization: Bearer <api_token>`.
        Owners and admins can read the token from the LocalOps console.

````