Stacks Node RPC API

openapi: 3.1.0
servers:
  - url: http://localhost:20443
    description: Local Stacks Node
info:
  title: Stacks 3.0+ RPC API
  version: "1.0.0"
  description: |
    This is the documentation for the `stacks-node` RPC interface.
  license:
    name: CC-0
    url: https://creativecommons.org/publicdomain/zero/1.0/

tags:
  - name: Transactions
    description: Operations related to broadcasting and retrieving transactions.
  - name: Smart Contracts
    description: Endpoints for interacting with Clarity smart contracts.
  - name: Accounts
    description: Endpoints for retrieving account information.
  - name: Fees
    description: Endpoints for fee estimation.
  - name: Info
    description: General informational endpoints about the node.
  - name: Mining
    description: Endpoints related to Stacks block production and mining.
  - name: Blocks
    description: Operations for retrieving block and microblock data.
  - name: Signers
    description: Endpoints for retrieving signer information.
  - name: Atlas
    description: Operations related to the Atlas global namespace.
  - name: Microblocks
    description: Operations for retrieving and submitting microblocks.
  - name: StackerDB
    description: Endpoints for interacting with StackerDB instances.

components:
  securitySchemes:
    rpcAuth:
      type: apiKey
      in: header
      name: authorization
      description: |
        Plain-text secret value that must exactly equal the node's
        configured password, which is set as `connection_options.auth_token`
        in the node's configuration file.
  responses:
    Unauthorized:
      description: Unauthorized. Invalid or missing authentication token.
      content:
        text/plain:
          schema:
            type: string
          example: "Unauthorized"
    BadRequest:
      description: Bad request
      content:
        text/plain:
          schema:
            type: string
          example: "Bad request"
    NotFound:
      description: Not found
      content:
        text/plain:
          schema:
            type: string
          example: "Not found"
    InternalServerError:
      description: Internal Server Error
      content:
        text/plain:
          schema:
            type: string
          example: "Internal Server Error"
    MethodNotAllowed:
      description: Method Not Allowed
      content:
        text/plain:
          schema:
            type: string
          example: "Method Not Allowed. Allowed: GET"
    Timeout:
      description: Timeout
      content:
        text/plain:
          schema:
            type: string
          example: "Timeout"
  schemas:
    NodeInfo:
      $ref: ./components/schemas/node-info.schema.yaml
    PoxInfo:
      $ref: ./components/schemas/pox-info.schema.yaml
    Sortitions:
      $ref: ./components/schemas/sortitions.schema.yaml
    GetHealth:
      $ref: ./components/schemas/get-health.schema.yaml
    AccountData:
      $ref: ./components/schemas/account-data.schema.yaml

    # Transaction Schemas
    TransactionSubmissionError:
      $ref: ./components/schemas/transaction-submission-error.schema.yaml
    FeeTransactionRequest:
      $ref: ./components/schemas/fee-transaction-request.schema.yaml
    FeeTransactionResponse:
      $ref: ./components/schemas/fee-transaction-response.schema.yaml
    FeeTransactionError:
      $ref: ./components/schemas/fee-transaction-error.schema.yaml

    # Contract & Clarity Schemas
    ContractInterface:
      $ref: ./components/schemas/contract-interface.schema.yaml
    ContractSource:
      $ref: ./components/schemas/contract-source.schema.yaml
    ReadOnlyFunctionArgs:
      $ref: ./components/schemas/read-only-function-args.schema.yaml
    ReadOnlyFunctionResult:
      $ref: ./components/schemas/read-only-function-result.schema.yaml
    ClarityName:
      $ref: ./components/schemas/clarity-name.schema.yaml
    ClarityMetadata:
      $ref: ./components/schemas/clarity-metadata.schema.yaml
    ConstantValue:
      $ref: ./components/schemas/constant-value.schema.yaml
    IsTraitImplemented:
      $ref: ./components/schemas/is-trait-implemented.schema.yaml

    # Other Schemas
    SignerBlocksSigned:
      $ref: ./components/schemas/signer-blocks-signed.schema.yaml
    UnconfirmedTransaction:
      $ref: ./components/schemas/unconfirmed-transaction.schema.yaml
    BlockUploadResponse:
      $ref: ./components/schemas/block-upload-response.schema.yaml
    AttachmentInventory:
      $ref: ./components/schemas/attachment-inventory.schema.yaml
    AttachmentData:
      $ref: ./components/schemas/attachment-data.schema.yaml
    StackerDbMetadata:
      $ref: ./components/schemas/stackerdb-metadata.schema.yaml
    StackerDbReplicas:
      $ref: ./components/schemas/stackerdb-replicas.schema.yaml
    StackerDbChunkData:
      $ref: ./components/schemas/stackerdb-chunk-data.schema.yaml
    StackerDbChunkAckData:
      $ref: ./components/schemas/stackerdb-chunk-ack-data.schema.yaml
    ClarityData:
      $ref: ./components/schemas/clarity-data.schema.yaml
    BlockHeaders:
      $ref: ./components/schemas/block-headers.schema.yaml
    BlockProposalResponse:
      $ref: ./components/schemas/block-proposal.schema.yaml
    NetworkPeers:
      $ref: ./components/schemas/network-peers.schema.yaml
    TransactionInfo:
      $ref: ./components/schemas/get-transaction.schema.yaml
    TenureForkInfo:
      $ref: ./components/schemas/tenure-fork-info.schema.yaml
    TenureInfo:
      $ref: ./components/schemas/tenure-info.schema.yaml
    TenureTip:
      $ref: ./components/schemas/tenure-tip.schema.yaml
    TenureTipMetadata:
      $ref: ./components/schemas/tenure-tip-metadata.schema.yaml
    GetStackerSet:
      $ref: ./components/schemas/get-stacker-set.schema.yaml
    TenureBlocks:
      $ref: ./components/schemas/tenure-blocks.schema.yaml
    BlockReplay:
      $ref: ./components/schemas/block-replay.schema.yaml

paths:
  /v2/transactions:
    post:
      summary: Broadcast raw transaction
      tags:
        - Transactions
      security: []
      description: |
        Broadcast raw transactions on the network. You can use the [@stacks/transactions](https://github.com/blockstack/stacks.js)
        project to generate a raw transaction payload.

        The node performs static validation checks on transactions before accepting them into the mempool, including:
        - Transaction format validation
        - Signature verification
        - Nonce checking
        - Fee validation
        - Size limits
      operationId: broadcastTransaction
      requestBody:
        required: true
        content:
          application/octet-stream:
            schema:
              type: string
              format: binary
              minLength: 1
            example: binary format of 00000000010400bed38c2aadffa348931bcb542880ff79d607afec000000000000000000000000000000c800012b0b1fff6cccd0974966dcd665835838f0985be508e1322e09fb3d751eca132c492bda720f9ef1768d14fdabed6127560ba52d5e3ac470dcb60b784e97dc88c9030200000000000516df0ba3e79792be7be5e50a370289accfc8c9e032000000000000303974657374206d656d6f00000000000000000000000000000000000000000000000000
          application/json:
            schema:
              type: object
              required: ["tx"]
              properties:
                tx:
                  type: string
                  pattern: "^[0-9a-f]+$"
                  description: Hex-encoded transaction
                attachment:
                  type: string
                  pattern: "^[0-9a-f]+$"
                  description: Optional hex-encoded attachment for contract-call transactions
            example:
              tx: "00000000010400bed38c2aadffa348931bcb542880ff79d607afec000000000000000000000000000000c800012b0b1fff6cccd0974966dcd665835838f0985be508e1322e09fb3d751eca132c492bda720f9ef1768d14fdabed6127560ba52d5e3ac470dcb60b784e97dc88c9030200000000000516df0ba3e79792be7be5e50a370289accfc8c9e032000000000000303974657374206d656d6f00000000000000000000000000000000000000000000000000"
              attachment: "68656c6c6f20776f726c64"
      responses:
        "200":
          description: Transaction ID of successful post of a raw tx to the node's mempool.
          content:
            application/json:
              schema:
                type: string
                pattern: "^[0-9a-f]{64}$"
                example: "e161978626f216b2141b156ade10501207ae535fa365a13ef5d7a7c9310a09f2"
        "400":
          description: Bad request
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/TransactionSubmissionError"
              examples:
                transaction-submission-error:
                  $ref: "./components/examples/transaction-submission-error.example.json"
            text/plain:
              schema:
                type: string
              example: "Failed to decode transaction"
        "500":
          $ref: "#/components/responses/InternalServerError"

  /v2/contracts/interface/{deployer_address}/{contract_name}:
    get:
      summary: Get contract interface
      description: Get contract interface using a `deployer_address` and `contract name`
      tags:
        - Smart Contracts
      security: []
      operationId: getContractInterface
      parameters:
        - $ref: ./components/parameters/deployer-address.yaml
        - $ref: ./components/parameters/contract-name.yaml
        - $ref: ./components/parameters/tip.yaml
      responses:
        "200":
          description: Contract interface
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ContractInterface"
              examples:
                contract-interface:
                  $ref: "./components/examples/contract-interface.example.json"
        "400":
          $ref: "#/components/responses/BadRequest"
        "404":
          $ref: "#/components/responses/NotFound"
        "500":
          $ref: "#/components/responses/InternalServerError"

  /v2/map_entry/{deployer_address}/{contract_name}/{map_name}:
    post:
      summary: Get specific data-map inside a contract
      tags:
        - Smart Contracts
      security: []
      operationId: getContractDataMapEntry
      description: |
        Attempt to fetch data from a contract data map. The contract is
        identified with [Stacks Address] and [Contract Name] in the URL path.
        The map is identified with [Map Name].

        The key to lookup in the map is supplied via the POST body. This should
        be supplied as the hex string serialization of the key (which should be
        a Clarity value). Note, this is a JSON string.

        The response is a JSON object with the following properties:
        - `data`: The hex serialization of the map response. Note that map
          responses are Clarity option types, for non-existent values, this is
          a serialized none, and for all other responses, it is a serialized
          (some ...) object.
        - `proof`: The hex serialization of the Merkle proof for the data.

      parameters:
        - $ref: ./components/parameters/deployer-address.yaml
        - $ref: ./components/parameters/contract-name.yaml
        - name: map_name
          in: path
          required: true
          schema:
            $ref: "#/components/schemas/ClarityName"
        - $ref: ./components/parameters/proof.yaml
        - $ref: ./components/parameters/tip.yaml
      x-codegen-request-body-name: key
      requestBody:
        description: Hex string serialization of the lookup key (which should be a Clarity value)
        required: true
        content:
          application/json:
            schema:
              type: string
              minLength: 2
              pattern: "^(0x)?([0-9a-fA-F]{2})+$"
              description: Hex-encoded Clarity value (e.g. "0x0100000000000000000000000000000001")
              example: "0x0100000000000000000000000000000001"
      responses:
        "200":
          description: Success
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ClarityData"
              examples:
                clarity-data:
                  $ref: "./components/examples/clarity-data.example.json"
        "400":
          $ref: "#/components/responses/BadRequest"
        "404":
          $ref: "#/components/responses/NotFound"
        "500":
          $ref: "#/components/responses/InternalServerError"

  /v2/contracts/source/{deployer_address}/{contract_name}:
    get:
      summary: Get contract source
      tags:
        - Smart Contracts
      security: []
      operationId: getContractSource
      description: |
        Returns the Clarity source code of a given contract, along with the
        block height it was published in, and the MARF proof for the data.
      parameters:
        - $ref: ./components/parameters/deployer-address.yaml
        - $ref: ./components/parameters/contract-name.yaml
        - $ref: ./components/parameters/proof.yaml
        - $ref: ./components/parameters/tip.yaml
      responses:
        "200":
          description: Success
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ContractSource"
              examples:
                contract-source:
                  $ref: "./components/examples/contract-source.example.json"
        "400":
          $ref: "#/components/responses/BadRequest"
        "404":
          $ref: "#/components/responses/NotFound"
        "500":
          $ref: "#/components/responses/InternalServerError"

  /v2/contracts/call-read/{deployer_address}/{contract_name}/{function_name}:
    post:
      summary: Call read-only function
      description: |
        Call a read-only public function on a given contract.

        The contract is identified with [Stacks Address] and [Contract Name] in the URL path.
        The function is identified with [Function Name].

        The arguments to the function are supplied via the POST body.
        This should be a JSON object with two main properties:
        - `sender` which should be a Stacks address or contract principal
        - `arguments` which should be an array of hex-encoded Clarity values.
      tags:
        - Smart Contracts
      security: []
      operationId: callReadOnlyFunction
      parameters:
        - $ref: ./components/parameters/deployer-address.yaml
        - $ref: ./components/parameters/contract-name.yaml
        - name: function_name
          in: path
          required: true
          schema:
            $ref: "#/components/schemas/ClarityName"
        - $ref: ./components/parameters/tip.yaml
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/ReadOnlyFunctionArgs"
      responses:
        "200":
          description: Function executed successfully
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ReadOnlyFunctionResult"
              examples:
                success:
                  $ref: "./components/examples/read-only-function-success.example.json"
                failure:
                  $ref: "./components/examples/read-only-function-failure.example.json"
        "400":
          $ref: "#/components/responses/BadRequest"
        "404":
          $ref: "#/components/responses/NotFound"
        "500":
          $ref: "#/components/responses/InternalServerError"

  /v3/contracts/fast-call-read/{deployer_address}/{contract_name}/{function_name}:
    post:
      summary: Call read-only function in fast mode (no cost and memory tracking)
      description: |
        Call a read-only public function on a given smart contract without cost tracking.

        The contract is identified with [Stacks Address] and [Contract Name] in the URL path.
        The function is identified with [Function Name].

        The arguments to the function are supplied via the POST body.
        This should be a JSON object with two main properties:
        - `sender` which should be a Stacks address or contract principal
        - `arguments` which should be an array of hex-encoded Clarity values.

        **This API endpoint requires a basic Authorization header.**
      tags:
        - Smart Contracts
      security:
        - rpcAuth: []
      operationId: fastCallReadOnlyFunction
      parameters:
        - $ref: ./components/parameters/deployer-address.yaml
        - $ref: ./components/parameters/contract-name.yaml
        - name: function_name
          in: path
          required: true
          schema:
            $ref: "#/components/schemas/ClarityName"
        - $ref: ./components/parameters/tip.yaml
      requestBody:
        description: map of arguments and the simulated tx-sender where sender is either a Contract identifier or a normal Stacks address, and arguments is an array of hex serialized Clarity values.
        required: true
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/ReadOnlyFunctionArgs"
            examples:
              fast-call-request:
                summary: Fast call read-only function request
                value:
                  sender: "SP31DA6FTSJX2WGTZ69SFY11BH51NZMB0ZW97B5P0.get-info"
                  arguments:
                    - "0x0011..."
                    - "0x00231..."
      responses:
        "200":
          description: Function executed successfully
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ReadOnlyFunctionResult"
              examples:
                success:
                  $ref: "./components/examples/read-only-function-success.example.json"
                failure:
                  $ref: "./components/examples/read-only-function-failure.example.json"
        "400":
          $ref: "#/components/responses/BadRequest"
        "401":
          $ref: "#/components/responses/Unauthorized"
        "404":
          $ref: "#/components/responses/NotFound"
        "408":
          $ref: "#/components/responses/Timeout"
        "500":
          $ref: "#/components/responses/InternalServerError"

  /v2/accounts/{principal}:
    get:
      summary: Get account info
      tags:
        - Accounts
      security: []
      operationId: getAccountInfo
      description: |
        Get the account data for the provided principal

        Where balance is the hex encoding of a unsigned 128-bit integer (big-endian), nonce is a unsigned 64-bit integer, and the proofs are provided as hex strings.

        For non-existent accounts, this does not 404, rather it returns an object with balance and nonce of 0.
      parameters:
        - $ref: ./components/parameters/principal.yaml
        - $ref: ./components/parameters/proof.yaml
        - $ref: ./components/parameters/tip.yaml
      responses:
        "200":
          description: Success
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/AccountData"
              examples:
                account-data:
                  $ref: "./components/examples/account-data.example.json"
        "400":
          $ref: "#/components/responses/BadRequest"
        "404":
          $ref: "#/components/responses/NotFound"
        "500":
          $ref: "#/components/responses/InternalServerError"

  /v2/fees/transaction:
    post:
      summary: Get approximate fees for the given transaction
      tags:
        - Fees
      security: []
      description: |
        Get an estimated fee for the supplied transaction.  This
        estimates the execution cost of the transaction, the current
        fee rate of the network, and returns estimates for fee
        amounts.

        * `transaction_payload` is a hex-encoded serialization of
          the TransactionPayload for the transaction.
        * `estimated_len` is an optional argument that provides the
          endpoint with an estimation of the final length (in bytes)
          of the transaction, including any post-conditions and
          signatures

        If the node cannot provide an estimate for the transaction
        (e.g., if the node has never seen a contract-call for the
        given contract and function) or if estimation is not
        configured on this node, a 400 response is returned.
        The 400 response will be a JSON error containing a `reason`
        field which can be one of the following:

        * `DatabaseError` - this Stacks node has had an internal
          database error while trying to estimate the costs of the
          supplied transaction.
        * `NoEstimateAvailable` - this Stacks node has not seen this
          kind of contract-call before, and it cannot provide an
          estimate yet.
        * `CostEstimationDisabled` - this Stacks node does not perform
          fee or cost estimation, and it cannot respond on this
          endpoint.

        The 200 response contains the following data:

        * `estimated_cost` - the estimated multi-dimensional cost of
          executing the Clarity VM on the provided transaction.
        * `estimated_cost_scalar` - a unitless integer that the Stacks
          node uses to compare how much of the block limit is consumed
          by different transactions. This value incorporates the
          estimated length of the transaction and the estimated
          execution cost of the transaction. The range of this integer
          may vary between different Stacks nodes. In order to compute
          an estimate of total fee amount for the transaction, this
          value is multiplied by the same Stacks node"s estimated fee
          rate.
        * `cost_scalar_change_by_byte` - a float value that indicates how
          much the `estimated_cost_scalar` value would increase for every
          additional byte in the final transaction.
        * `estimations` - an array of estimated fee rates and total fees to
          pay in microSTX for the transaction. This array provides a range of
          estimates (default: 3) that may be used. Each element of the array
          contains the following fields:
            * `fee_rate` - the estimated value for the current fee
              rates in the network
            * `fee` - the estimated value for the total fee in
              microSTX that the given transaction should pay. These
              values are the result of computing:
              `fee_rate` x `estimated_cost_scalar`.
              If the estimated fees are less than the minimum relay
              fee `(1 ustx x estimated_len)`, then that minimum relay
              fee will be returned here instead.


        Note: If the final transaction"s byte size is larger than
        supplied to `estimated_len`, then applications should increase
        this fee amount by:

          `fee_rate` x `cost_scalar_change_by_byte` x (`final_size` - `estimated_size`)

      operationId: getFeeTransaction
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/FeeTransactionRequest"
            examples:
              fee-transaction-request:
                summary: Fee estimation request
                value:
                  estimated_len: 350
                  transaction_payload: "021af942874ce525e87f21bbe8c121b12fac831d02f4086765742d696e666f0b7570646174652d696e666f00000000"
      responses:
        "200":
          description: Estimated fees for the transaction
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/FeeTransactionResponse"
              examples:
                fee-transaction-response:
                  $ref: "./components/examples/fee-transaction-response.example.json"
        "400":
          description: Fee estimation error
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/FeeTransactionError"
            text/plain:
              schema:
                type: string
              example: "Failed to decode: Failed to parse JSON body"
        "500":
          $ref: "#/components/responses/InternalServerError"

  /v2/fees/transfer:
    get:
      summary: Get estimated fee
      tags:
        - Fees
      security: []
      operationId: getFeeTransfer
      description: |
        Get an estimated fee rate for STX transfer transactions. This is a fee
        rate per byte, returned as a JSON integer (microSTX per byte).
      responses:
        "200":
          description: Fee rate in microSTX per byte
          content:
            application/json:
              schema:
                type: integer
                minimum: 1
                description: Fee rate in microSTX per byte
              example: 3
        "500":
          $ref: "#/components/responses/InternalServerError"

  /v2/info:
    get:
      summary: Get Core API info
      description: Get Core API information
      tags:
        - Info
      security: []
      operationId: getNodeInfo
      responses:
        "200":
          description: Success
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/NodeInfo"
              examples:
                node-info:
                  $ref: "./components/examples/node-info.example.json"
        "500":
          $ref: "#/components/responses/InternalServerError"

  /v2/pox:
    get:
      summary: Get PoX details
      description: Get Proof of Transfer (PoX) information. Can be used for Stacking.
      tags:
        - Info
      security: []
      operationId: getPoxInfo
      responses:
        "200":
          description: Success
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/PoxInfo"
              examples:
                pox-info:
                  $ref: "./components/examples/pox-info.example.json"
        "400":
          $ref: "#/components/responses/BadRequest"
        "404":
          $ref: "#/components/responses/NotFound"
        "500":
          $ref: "#/components/responses/InternalServerError"
      parameters:
        - $ref: ./components/parameters/tip.yaml

  /v2/traits/{deployer_address}/{contract_name}/{trait_deployer_address}/{trait_contract_name}/{trait_name}:
    get:
      summary: Get trait implementation details
      description: |
        Determine whether or not a specified trait is implemented (either
        explicitly or implicitly) within a given contract.
      tags:
        - Smart Contracts
      security: []
      operationId: checkTraitImplementation
      parameters:
        - $ref: ./components/parameters/deployer-address.yaml
        - $ref: ./components/parameters/contract-name.yaml
        - name: trait_deployer_address
          in: path
          required: true
          description: |
            Stacks address of the trait-defining contract.
          schema:
            $ref: './components/schemas/standard-principal.schema.yaml'
        - name: trait_contract_name
          in: path
          required: true
          description: Contract name of the trait-defining contract.
          schema:
            type: string
            pattern: "^[a-zA-Z]([a-zA-Z0-9]|[-_]){0,127}$"
            minLength: 1
            maxLength: 128
            example: "some-trait"
        - name: trait_name
          in: path
          required: true
          schema:
            $ref: "#/components/schemas/ClarityName"
          example: "some-trait"
        - $ref: ./components/parameters/tip.yaml
      responses:
        "200":
          description: Success
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/IsTraitImplemented"
              examples:
                is-trait-implemented:
                  $ref: "./components/examples/is-trait-implemented.example.json"
        "400":
          $ref: "#/components/responses/BadRequest"
        "404":
          $ref: "#/components/responses/NotFound"

  /v2/clarity/marf/{marf_key_hash}:
    get:
      summary: Get the MARF value for a given key
      tags:
        - Smart Contracts
      security: []
      operationId: getClarityMarfValue
      description: |
        Attempt to fetch the value of a MARF key. The key is a 64-character
        hex string representing the MARF node hash.
      responses:
        "200":
          description: Success
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ClarityData"
              examples:
                clarity-data:
                  $ref: "./components/examples/clarity-data.example.json"
        "400":
          $ref: "#/components/responses/BadRequest"
        "404":
          $ref: "#/components/responses/NotFound"
      parameters:
        - name: marf_key_hash
          in: path
          required: true
          description: The 64-character hex-encoded hash of the MARF key.
          schema:
            type: string
            pattern: "^[0-9a-f]{64}$"
            minLength: 64
            maxLength: 64
        - $ref: ./components/parameters/proof.yaml
        - $ref: ./components/parameters/tip.yaml

  /v2/clarity/metadata/{deployer_address}/{contract_name}/{clarity_metadata_key}:
    get:
      summary: Get the contract metadata for the metadata key
      tags:
        - Smart Contracts
      security: []
      operationId: getClarityMetadata
      description: |
        Attempt to fetch the metadata of a contract. The contract is identified
        with [Contract Address] and [Contract Name] in the URL path. The metadata
        key is identified with [Clarity Metadata Key].

        In the response, `data` is formatted as JSON.
      responses:
        "200":
          description: Success
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ClarityMetadata"
              examples:
                clarity-metadata:
                  $ref: "./components/examples/clarity-metadata.example.json"
        "400":
          $ref: "#/components/responses/BadRequest"
        "404":
          $ref: "#/components/responses/NotFound"
        "500":
          $ref: "#/components/responses/InternalServerError"
      parameters:
        - $ref: ./components/parameters/deployer-address.yaml
        - $ref: ./components/parameters/contract-name.yaml
        - name: clarity_metadata_key
          in: path
          required: true
          description: |
            Metadata key. Must be either:
            - "analysis" for contract analysis data
            - "vm-metadata::N::TYPE" where N is the epoch (1-2 digits) and TYPE is one of:
              contract, contract-size, contract-src, contract-data-size, or a valid Clarity name
          schema:
            type: string
            pattern: "^(analysis)|(vm-metadata::\\d{1,2}::(contract|contract-size|contract-src|contract-data-size|[a-zA-Z]([a-zA-Z0-9]|[-_!?+<>=/*])*))$"
            example: analysis
        - $ref: ./components/parameters/tip.yaml

  /v2/constant_val/{deployer_address}/{contract_name}/{constant_name}:
    get:
      summary: Get the value of a constant inside a contract
      tags:
        - Smart Contracts
      security: []
      operationId: getConstantValue
      description: |
        Attempt to fetch the value of a constant inside a contract. The contract
        is identified with [Stacks Address] and [Contract Name] in the URL path.
        The constant is identified with [Constant Name].

        In the response, `data` is the hex serialization of the constant value.
      responses:
        "200":
          description: Success
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ConstantValue"
              examples:
                constant-value:
                  $ref: "./components/examples/constant-value.example.json"
        "400":
          $ref: "#/components/responses/BadRequest"
        "404":
          $ref: "#/components/responses/NotFound"
        "500":
          $ref: "#/components/responses/InternalServerError"
      parameters:
        - $ref: ./components/parameters/deployer-address.yaml
        - $ref: ./components/parameters/contract-name.yaml
        - name: constant_name
          in: path
          required: true
          schema:
            $ref: "#/components/schemas/

# --- truncated at 32 KB (85 KB total) ---
# Full source: https://raw.githubusercontent.com/api-evangelist/hiro/refs/heads/main/openapi/hiro-stacks-node-rpc-api-openapi.yaml