Unstoppable Domains Partner API

openapi: 3.1.0
info:
  title: Web3 Partner API v3
  version: "3.0.0"
  contact:
    name: Unstoppable Domains (Partner Engineering)
    email: [email protected]
  description: |
    # Feature Overview
    The Web3 Partner API v3 provides you with the ability to lookup, register and manage Web3 domains. The API exposes a RESTful interface for interacting with Web3 domains and the Unstoppable Domains registry.
    - Lookup Domains: Search for specific domains or find suggested alternatives, to determine pricing, availability and on-chain details
    - Registering Domains: Secure domains into your dedicated Custody wallets to maintain the domains on the blockchain
    - Manage Domains: Update records on the blockchain or transfer the domain to external owners, all through a simple API interface

    ## Custody Solution
    The API takes the hassle of Web3 out of the equation. Unstoppable Domains will handle all blockchain interactions and concepts, while Partners simply use a RESTful API for managing domains.

    Since the domains will be in custody of the Partner, through Unstoppable Domains, the Partner is empowered to make any and all changes to the domains on behalf of their users.

    Under the hood, Unstoppable Domains will manage dedicated custodial wallets for Partner-owned domains. These wallets are not shared between Partners and will uniquely identify the Partner on the various supported blockchains.

    Should the need arise to remove domains from custody, this is supported by changing the owner of domains to external owners.

    ## Payments
    The API will keep track of a running balance of charges and Unstoppable Domains will periodically invoice Partners to settle that balance. This empowers Partners to build payment processing in a way that works best for them.


    ## Blockchain Support
    Domain details can be viewed across all of our supported blockchains:
    - Ethereum (ETH)
    - Polygon PoS (MATIC)
    - Base (BASE)

    Domains can **only be managed on Polygon PoS (MATIC) and Base (BASE)**. Domains on Ethereum (ETH) are readonly, but management support is coming soon.

    # Important Concepts
    The API has some important concepts, in addition to Web3 Domains, that provide added utility, consistency and information.

    ## Domain Ownership Type
    Web3 domains exist on the supported Blockchains, and are owned by wallet addresses associated with those Blockchains. 
    We take ownership a step further, to provide improved security and reliability, by including an owner `type` in our ownership data.
    The result is that a Domain's owner is defined by two values: `address` and `type`

    The owner `type` can be one of the following:
    - `NONE`: Either the domain has never been owned or belongs to a "burn" address
    - `UD`: Owned by Unstoppable Domains
    - `SELF`: Domain belongs to a wallet addressed associated with your account, indicating you are able to manage it via the API
    - `EXTERNAL`: Owner doesn't qualify as any of the above. Changing to an `EXTERNAL` owner will result in the domain belonging to an address outside of the management of Unstoppable Domains and we will have no way to recover it.

    By defining an owner in two parts (`address` and `type`) we ensure any irreversible action, such as transferring ownership, is deliberate and intended by requiring both the `address` and `type` in the request.

    ## Operations
    All interactions with the API that initiate changes will create an Operation for tracking that change.
    Operations can complete immediately or run in the background over the course of several minutes, depending on the Operation type and current conditions on the Blockchain.

    Operations include dependencies that represent the smaller units of work associated with the overall operation. These dependencies can also be tracked through the API and each have their own status and metadata.

    Your integration should properly handle and anticipate all of the following possible statuses for Operations and their dependencies:
    - `QUEUED` : The Operation has not started processing yet, but should be started shortly
    - `PROCESSING` : The Operation has started, often involving sending transactions to the Blockchain
    - `SIGNATURE_REQUIRED`: The operation is awaiting a signature in order to continue processing. This is only relevant to Self-Custody domain management.
    - `COMPLETED` : The Operation has finished processing successfully
    - `FAILED` : The Operation has finished processing and has either fully or partially failed
    - `CANCELLED` : The Operation has been cancelled, usually due to a failure with a sibling dependency

    See the [Operations](/openapi/partner/v3/#tag/operations) API for additional information.

    ## Wallets
    Domains ownership on the Blockchain is handled by associating a Domain with an "address". These addresses are typically managed by Wallets (usually in the form of an application on your computer or mobile device) that manage the private key for the public "address".

    The API provides endpoints for creating/managing Wallets within your account to enable you to handle Domain ownership distribution in whatever way works for you. Any Domain that is owned by one of your account's Wallets is fully in your control to manage.

    See the [Wallets](/openapi/partner/v3/#tag/wallets) API for additional information.

    # Get Access
    See our quickstart guide for getting your Partner API key: [Set up Partner API Access](https://docs.unstoppabledomains.com/domain-distribution-and-management/quickstart/retrieve-an-api-key/)

    If you have any questions, contact our [Partner Engineering Team](mailto:[email protected]?subject=Partner%20API%20v3%20Inquiry) to help with API access or learn more.
tags:
  - name: suggestions
    x-displayName: Suggestions
    description: Suggestions for finding available domains
  - name: domain_registration
    x-displayName: Domain Lookup & Registration
    description: |
      Domain details/availability lookups and registration.
  - name: wallets
    x-displayName: Custody Wallets
    description: | 
      Manage custody wallets used for storing and managing domains without any signature collection.

      These wallets provide the most streamlined way to interact with domains since the initial management request is the only step needed to make changes.

  - name: domains
    x-displayName: Custody Domains
    description: Manage your custody domains.

  - name: external_wallets
    x-displayName: Self-Custody Wallets
    description: |
      Manage self-custody wallets to allow for management of self-custody domains.

      ## Verifying Self-Custody Wallets
      Before you can initiate self-custody operations, you must first [verify the self-custody wallet](/openapi/partner/v3/#operation/getExternalWalletVerification) (only needs to be done once per wallet).

      This involves:
      1. [Fetching a verification message to sign](/openapi/partner/v3/#operation/getExternalWalletVerification)
      2. Collecting a `personal_sign` signature from the wallet owner
      3. [Submitting the signature](/openapi/partner/v3/#operation/postExternalWalletVerification) to register the verified wallet

      After verifying a wallet, it will be returned by the Single-Wallet and Wallet List routes, with the type of `EXTERNAL`.

      ## Supported Self-Custody Wallets
      - Externally Owned Accounts (EOAs)
      - [ERC1271](https://eips.ethereum.org/EIPS/eip-1271) Smart Contract wallets deployed on Polygon

  - name: external_domains
    x-displayName: Self-Custody Domains
    description: |
      Manage domains that are owned in external, self-custody wallets.

      The key difference between Custody and Self-Custody operations is that all Self-Custody operations require a signature from the domain owner.

      Before you can initiate self-custody operations, you must [verify the self-custody wallet](/openapi/partner/v3/#tag/external_wallets) that owns the domain.

      ## Signing Self-Custody Operations
      After you successfully initiate a self-custody operation, it will have a status of `SIGNATURE_REQUIRED`. You then need to collect a signature of the `messageToSign` from the `operation.dependencies[].transaction` object. 

      After the owner has signed the message, you use the [dependency update route](/openapi/partner/v3/#operation/patchOperationDependency) to submit the signature and continue processing the operation.

  - name: operations
    x-displayName: Operations
    description: |
      All asynchronous processes handled by the API are represented as Operations. This includes registering a domain, updating a domain's records, changing a domain's owner, returning a domain and more.
  - name: account
    x-displayName: Account
    description: Manage your account details
  - name: owners
    x-displayName: Owners
    description: Search for owned domains
  - name: search
    x-displayName: Search
    description: Search for owned entities
  - name: webhooks
    x-displayName: Webhooks
    description: |
      Manage webhooks used for asynchronous updates to your server.

      You can follow our getting started guide here: [Webhooks in the Partner API](https://docs.unstoppabledomains.com/domain-distribution-and-management/guides/implementing-webhooks/)
servers:
  - url: "https://api.unstoppabledomains.com/partner/v3"
    description: Production
  - url: "https://api.ud-sandbox.com/partner/v3"
    description: Sandbox
paths:
  /domains:
    get:
      operationId: getMultipleDomains
      summary: "Lookup multiple domain details and availability"
      description: |
        Get domain availability and owner details for multiple domains using the query string search options. Optionally, use the `$expand` query string to include additional data in the response (ie. `?$expand=records&$expand=registration`).

        If the domain is available to be registered it will have a `availability.status` of `AVAILABLE` and will include an `availability.price` object.
      parameters:
        - name: $expand
          required: false
          in: query
          schema:
            type: array
            description: Use `$expand` options to conditionally include portions of the response
            items:
              type: string
              enum:
                - records
                - registration
        - name: tlds
          required: false
          deprecated: true
          description: Use `ending` instead
          in: query
          schema:
            type: array
            items:
              type: string
              example: "crypto"
        - name: ending
          required: false
          in: query
          description: TLD or Parent Domain to apply to your `query` base names
          schema:
            type: array
            items:
              anyOf:
                - type: string
                  example: "example-name"
                - $ref: "#/components/schemas/DomainName"
        - name: query
          required: true
          in: query
          schema:
            type: array
            items:
              anyOf:
                - type: string
                  example: "example-name"
                - $ref: "#/components/schemas/DomainName"
      responses:
        200:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/MultipleDomainSearchResponse"
        400:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorResponse"
              examples:
                ValidationError:
                  $ref: "#/components/examples/ValidationError"
      tags:
        - domain_registration
    post:
      operationId: mintSingleDomain
      summary: "Register a domain"
      description: |
        If a domain is available, use this route to register it to your account. The domain will be minted or transfered to your custodial wallet where only Unstoppable Domains, on your behalf, will be able to make changes to it.

        The price of the domain will be automatically added to your running balance with Unstoppable Domains. The pending balance of your account will be invoiced periodically.

        ### Register to specific owner
        If you do not provide an `owner` in your request, your account's default wallet address will be used as the owner. Use `GET /account` to confirm your default wallet address.

        When providing an `owner` object in your request, be sure the `type` aligns with the `address`. To register to one of your own wallets, the `type` must be `SELF`. Use `GET /account/wallets` to see your list of available wallets.

      parameters:
        - name: $preview
          in: query
          schema:
            $ref: "#/components/schemas/OperationPreviewParameter"
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/DomainMintRequestBody"
      responses:
        201:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/DomainOperationResponse"
        400:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorResponse"
              examples:
                ValidationError:
                  $ref: "#/components/examples/ValidationError"
                NotAvailable:
                  $ref: "#/components/examples/DomainNotAvailable"
                ExceedsLimit:
                  $ref: "#/components/examples/DomainExceedsLimit"
                InsufficientBalance:
                  $ref: "#/components/examples/InsufficientBalance"
      tags:
        - domain_registration
  "/domains/{name}":
    get:
      operationId: getSingleDomain
      summary: "Get domain details and availability"
      description: |
        Get information about the domain's current owner and availability status. Optionally, use the `$expand` query string to include additional data in the response (ie. `?$expand=records&$expand=registration`).

        If the domain is available to be registered it will have a `availability.status` of `AVAILABLE` and will include an `availability.price` object.
      parameters:
        - name: name
          required: true
          in: path
          schema:
            $ref: "#/components/schemas/DomainName"
        - name: $expand
          required: false
          description: Use `$expand` options to conditionally include portions of the response
          in: query
          schema:
            type: array
            items:
              type: string
              enum:
                - records
                - registration
      responses:
        200:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/DomainSearchResponse"
        400:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorResponse"
              examples:
                ValidationError:
                  $ref: "#/components/examples/ValidationError"
      tags:
        - domain_registration
    patch:
      operationId: updateDomainPatch
      summary: "Update a domain (partial update)"
      description: |
        Perform Domain updates while preserving the existing records.

        ### Change Owner with Records Preserved
        ```
        {
          "owner": {
            "type": "EXTERNAL",
            "address": "0x123"
          }
        }
        ```
        Changes owner to the new owner address without modifying the domain records.

        #### Owner Types
        When changing owner of a domain, you must provide both a `type` and an `address` to clearly indicate the intent of the change.
        - `NONE`: Used when changing the owner to a "burn" address, which will result in nobody owning the domain
          - Valid "burn" addresses are `0x0000000000000000000000000000000000000000` and `0x000000000000000000000000000000000000dEaD`
        - `UD`: Used when changing the owner to an addressed owned by Unstoppable Domains
        - `SELF`: Used when changing the owner to another address that belongs to your account
        - `EXTERNAL`: Used when changing the owner to address that doesn't qualify as any of the above. 
          - _WARNING_: This will result in the domain belonging to an address outside of the management of Unstoppable Domains and we will have no way to recover it.

        ### Update Records with existing Records Preserved
        ```
        {
          "records": {
            "key2": "value2"
          }
        }
        ```
        When applied to a domain with existing records, or with an existing `key2`, will result in only the `key2` value being set to the new value.

        See [our documentation](https://docs.unstoppabledomains.com/resolution/guides/records-reference/) for more information on standardized keys.
      parameters:
        - name: name
          required: true
          in: path
          schema:
            $ref: "#/components/schemas/DomainName"
        - name: $preview
          in: query
          schema:
            $ref: "#/components/schemas/OperationPreviewParameter"
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/DomainUpdateRequestBody"
      responses:
        200:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/DomainOperationResponse"
        400:
          description: "Validation error or bad request due to domain custody, unsupported blockchain, etc."
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorResponse"
              examples:
                ValidationError:
                  $ref: "#/components/examples/ValidationError"
                NoChange:
                  $ref: "#/components/examples/NoChange"
                ConcurrentOperation:
                  $ref: "#/components/examples/ConcurrentOperation"
                CustodyRequired:
                  $ref: "#/components/examples/CustodyRequired"
                UnsupportedBlockchain:
                  $ref: "#/components/examples/UnsupportedBlockchain"
                BadRequest:
                  $ref: "#/components/examples/BadRequest"
        502:
          $ref: "#/components/responses/502BadGateway"
      tags:
        - domains
    put:
      operationId: updateDomainPut
      summary: "Update a domain (overwriting update)"
      description: |
        Perform Domain updates while doing full resets of the records.

        ### Change Owner with Record Reset
        ```
        {
          "owner": {
            "type": "EXTERNAL",
            "address": "0x123"
          },
          "records": {}
        }
        ```
        Clears all records from the domain, then changes owner to the new owner address.

        NOTE: You must include `"records": {}` to indicate the intent to clear records.

        #### Owner Types
        When changing owner of a domain, you must provide both a `type` and an `address` to clearly indicate the intent of the change.
        - `NONE`: Used when changing the owner to a "burn" address, which will result in nobody owning the domain
          - Valid "burn" addresses are `0x0000000000000000000000000000000000000000` and `0x000000000000000000000000000000000000dEaD`
        - `UD`: Used when changing the owner to an addressed owned by Unstoppable Domains
        - `SELF`: Used when changing the owner to another address that belongs to your account
        - `EXTERNAL`: Used when changing the owner to address that doesn't qualify as any of the above.
          - _WARNING_: This will result in the domain belonging to an address outside of the management of Unstoppable Domains and we will have no way to recover it.

        ### Update Records with Record Reset
        ```
        {
          "records": {
            "key2": "value2"
          }
        }
        ```
        When applied to a domain with existing records, only `key2` will remain after the update is complete.

        See [our documentation](https://docs.unstoppabledomains.com/resolution/guides/records-reference/) for more information on standardized keys.
      parameters:
        - name: name
          required: true
          in: path
          schema:
            $ref: "#/components/schemas/DomainName"
        - name: $preview
          in: query
          schema:
            $ref: "#/components/schemas/OperationPreviewParameter"
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/DomainUpdateRequestBody"
      responses:
        200:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/DomainOperationResponse"
        400:
          description: "Validation error or bad request due to domain custody, unsupported blockchain, etc."
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorResponse"
              examples:
                ValidationError:
                  $ref: "#/components/examples/ValidationError"
                NoChange:
                  $ref: "#/components/examples/NoChange"
                ConcurrentOperation:
                  $ref: "#/components/examples/ConcurrentOperation"
                CustodyRequired:
                  $ref: "#/components/examples/CustodyRequired"
                UnsupportedBlockchain:
                  $ref: "#/components/examples/UnsupportedBlockchain"
                BadRequest:
                  $ref: "#/components/examples/BadRequest"
        502:
          $ref: "#/components/responses/502BadGateway"
      tags:
        - domains
    delete:
      operationId: returnDomain
      summary: "Return and refund a domain"
      description: |
        Return the domain to Unstoppable Domains so it is once again considered available for registering. The amount previously added to your running balance will be removed after successfully returning a domain.

        Returns are only allowed within 14 days of the original registration date, per our return policy.
      parameters:
        - name: name
          required: true
          in: path
          schema:
            type: string
        - name: $preview
          in: query
          schema:
            $ref: "#/components/schemas/OperationPreviewParameter"
      responses:
        200:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/DomainOperationResponse"
        400:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorResponse"
              examples:
                ValidationError:
                  $ref: "#/components/examples/ValidationError"
      tags:
        - domains
  "/external/domains/{name}":
    put:
      operationId: putExternalDomain
      summary: Update a self-custody domain (overwriting update)
      description: |
        Perform Self-Custody Domain updates while doing full resets of the records.
        Usage is the same as the [custody variant](/openapi/partner/v3/#operation/updateDomainPut).
      parameters:
        - name: name
          required: true
          in: path
          schema:
            $ref: "#/components/schemas/DomainName"
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/DomainUpdateRequestBody"
      responses:
        200:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/DomainOperationResponse"
        400:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorResponse"
              examples:
                ValidationError:
                  $ref: "#/components/examples/ValidationError"
                NoChange:
                  $ref: "#/components/examples/NoChange"
                ConcurrentOperation:
                  $ref: "#/components/examples/ConcurrentOperation"
                ExternalWalletNotVerified:
                  $ref: "#/components/examples/ExternalWalletNotVerified"
                UnsupportedBlockchain:
                  $ref: "#/components/examples/UnsupportedBlockchain"
                BadRequest:
                  $ref: "#/components/examples/BadRequest"
        502:
          description: "Blockchain access is currently degraded"
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorResponse"
              examples:
                BlockchainCongestion:
                  $ref: "#/components/examples/BlockchainCongestion"
      tags:
        - external_domains
    patch:
      operationId: patchExternalDomain
      summary: Update a self-custody domain (partial update)
      description: |
        Perform Self-Custody Domain updates while preserving the existing records.
        Usage is the same as the [custody variant](/openapi/partner/v3/#operation/updateDomainPatch).
      parameters:
        - name: name
          required: true
          in: path
          schema:
            $ref: "#/components/schemas/DomainName"
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/DomainUpdateRequestBody"
      responses:
        200:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/DomainOperationResponse"
        400:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorResponse"
              examples:
                ValidationError:
                  $ref: "#/components/examples/ValidationError"
                NoChange:
                  $ref: "#/components/examples/NoChange"
                ConcurrentOperation:
                  $ref: "#/components/examples/ConcurrentOperation"
                ExternalWalletNotVerified:
                  $ref: "#/components/examples/ExternalWalletNotVerified"
                UnsupportedBlockchain:
                  $ref: "#/components/examples/UnsupportedBlockchain"
                BadRequest:
                  $ref: "#/components/examples/BadRequest"
        502:
          description: "Blockchain access is currently degraded"
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorResponse"
              examples:
                BlockchainCongestion:
                  $ref: "#/components/examples/BlockchainCongestion"
      tags:
        - external_domains
  /operations:
    get:
      operationId: getOperationList
      summary: Get list of operations
      description: |
        Get paginated list of past operations, with the ability to filter based on various criteria.

        Results ordered with newest operations first.
      parameters:
        - name: domain
          required: false
          in: query
          schema:
            maxItems: 50
            type: array
            items:
              type: string
        - name: status
          required: false
          in: query
          schema:
            type: array
            items:
              $ref: "#/components/schemas/OperationStatus"
        - name: type
          required: false
          in: query
          schema:
            type: array
            items:
              $ref: "#/components/schemas/OperationType"
        - name: $cursor
          required: false
          description: The `next.$cursor` value from the previous page response
          in: query
          schema:
            type: string
      responses:
        "200":
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/OperationListResponse"
        400:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorResponse"
              examples:
                ValidationError:
                  $ref: "#/components/examples/ValidationError"
      tags:
        - operations
  "/operations/{id}":
    get:
      operationId: checkOperation
      summary: "Check operation status"
      description: |
        Use this endpoint to check on the status for any Operation being processed by the API.
      parameters:
        - name: id
          required: true
          in: path
          schema:
            type: string
      responses:
        200:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/OperationCheckResponse"
        400:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorResponse"
              examples:
                ValidationError:
                  $ref: "#/components/examples/ValidationError"
        404:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorResponse"
              examples:
                NotFound:
                  $ref: "#/components/examples/OperationNotFound"
      tags:
        - operations
  "/operations/{id}/dependencies/{depId}":
    patch:
      operationId: patchOperationDependency
      summary: Update operation dependency
      description: Sign operation dependency with status `SIGNATURE_REQUIRED` so it can continue processing
      parameters:
        - name: id
          required: true
          in: path
          schema:
            type: string
        - name: depId
          required: true
          in: path
          schema:
            type: string
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/OperationDependencyUpdateRequestBody"
      responses:
        "200":
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/OperationCheckResponse"
        400:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorResponse"
              examples:
                ValidationError:
                  $ref: "#/components/examples/ValidationError"
                InvalidSignature:
                  $ref: "#/components/examples/InvalidSignature"
        404:
          description: ""
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorResponse"
              examples:
                NotFound:
                  $ref: "#/components/examples/OperationNotFound"
      tags:
        - operations
  /suggestions/domains:
    get:
      operationId: getSuggestions
      summary: "Get suggested domains that are available for registering"
      description: All domains returned by this route are available for registration
      parameters:
        - name: tlds
          required: false
          deprecated: true
          description: Use `ending` instead
          in: query
          schema:
            type: array
            items:
              type: string
              example: "crypto"
        - name: ending
          required: false
          in: query
          description: TLD or Parent Domain to apply to your `query` base names
          schema:
            type: array
            items:
              anyOf:
                - type: string
                  example: "crypto"
              

# --- truncated at 32 KB (85 KB total) ---
# Full source: https://raw.githubusercontent.com/api-evangelist/unstoppable-domains/refs/heads/main/openapi/unstoppable-domains-partner-api-openapi.yaml