Stacks 3.0+ RPC API

v1.0.0

Base URL

https://stacks.nownodes.ioLocal

This is the documentation for the stacks-node RPC interface.

Authentication

api-keyAuthapiKey

API Key: api-key in header

Stacks

Transactions

Broadcast raw transaction

POST

https://stacks.nownodes.io/v2/transactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Broadcast raw transactions on the network. You can use the @stacks/transactions project to generate a raw transaction payload.

Body

application/octet-stream

string<binary>

Response

200OK

Transaction ID of successful post of a raw tx to the node's mempool

400Bad Request

Rejections result in a 400 error

Broadcast raw transaction

curl -X POST 'https://stacks.nownodes.io/v2/transactions' \
  -H 'Content-Type: application/octet-stream' \
  -d '"binary format of 00000000010400bed38c2aadffa348931bcb542880ff79d607afec000000000000000000000000000000c800012b0b1fff6cccd0974966dcd665835838f0985be508e1322e09fb3d751eca132c492bda720f9ef1768d14fdabed6127560ba52d5e3ac470dcb60b784e97dc88c9030200000000000516df0ba3e79792be7be5e50a370289accfc8c9e032000000000000303974657374206d656d6f00000000000000000000000000000000000000000000000000"'

const response = await fetch('https://stacks.nownodes.io/v2/transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/octet-stream',
  },
  body: JSON.stringify("binary format of 00000000010400bed38c2aadffa348931bcb542880ff79d607afec000000000000000000000000000000c800012b0b1fff6cccd0974966dcd665835838f0985be508e1322e09fb3d751eca132c492bda720f9ef1768d14fdabed6127560ba52d5e3ac470dcb60b784e97dc88c9030200000000000516df0ba3e79792be7be5e50a370289accfc8c9e032000000000000303974657374206d656d6f00000000000000000000000000000000000000000000000000"),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/transactions')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/octet-stream'
request.body = '"binary format of 00000000010400bed38c2aadffa348931bcb542880ff79d607afec000000000000000000000000000000c800012b0b1fff6cccd0974966dcd665835838f0985be508e1322e09fb3d751eca132c492bda720f9ef1768d14fdabed6127560ba52d5e3ac470dcb60b784e97dc88c9030200000000000516df0ba3e79792be7be5e50a370289accfc8c9e032000000000000303974657374206d656d6f00000000000000000000000000000000000000000000000000"'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = "binary format of 00000000010400bed38c2aadffa348931bcb542880ff79d607afec000000000000000000000000000000c800012b0b1fff6cccd0974966dcd665835838f0985be508e1322e09fb3d751eca132c492bda720f9ef1768d14fdabed6127560ba52d5e3ac470dcb60b784e97dc88c9030200000000000516df0ba3e79792be7be5e50a370289accfc8c9e032000000000000303974657374206d656d6f00000000000000000000000000000000000000000000000000"

response = requests.post('https://stacks.nownodes.io/v2/transactions', json=payload)
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v2/transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/octet-stream',
  },
  body: JSON.stringify("binary format of 00000000010400bed38c2aadffa348931bcb542880ff79d607afec000000000000000000000000000000c800012b0b1fff6cccd0974966dcd665835838f0985be508e1322e09fb3d751eca132c492bda720f9ef1768d14fdabed6127560ba52d5e3ac470dcb60b784e97dc88c9030200000000000516df0ba3e79792be7be5e50a370289accfc8c9e032000000000000303974657374206d656d6f00000000000000000000000000000000000000000000000000"),
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v2/transactions";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/octet-stream",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest("binary format of 00000000010400bed38c2aadffa348931bcb542880ff79d607afec000000000000000000000000000000c800012b0b1fff6cccd0974966dcd665835838f0985be508e1322e09fb3d751eca132c492bda720f9ef1768d14fdabed6127560ba52d5e3ac470dcb60b784e97dc88c9030200000000000516df0ba3e79792be7be5e50a370289accfc8c9e032000000000000303974657374206d656d6f00000000000000000000000000000000000000000000000000");
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v2/transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/octet-stream',
  },
  body: JSON.stringify("binary format of 00000000010400bed38c2aadffa348931bcb542880ff79d607afec000000000000000000000000000000c800012b0b1fff6cccd0974966dcd665835838f0985be508e1322e09fb3d751eca132c492bda720f9ef1768d14fdabed6127560ba52d5e3ac470dcb60b784e97dc88c9030200000000000516df0ba3e79792be7be5e50a370289accfc8c9e032000000000000303974657374206d656d6f00000000000000000000000000000000000000000000000000"),
});

const data = await response.json();

import requests

payload = "binary format of 00000000010400bed38c2aadffa348931bcb542880ff79d607afec000000000000000000000000000000c800012b0b1fff6cccd0974966dcd665835838f0985be508e1322e09fb3d751eca132c492bda720f9ef1768d14fdabed6127560ba52d5e3ac470dcb60b784e97dc88c9030200000000000516df0ba3e79792be7be5e50a370289accfc8c9e032000000000000303974657374206d656d6f00000000000000000000000000000000000000000000000000"

response = requests.post('https://stacks.nownodes.io/v2/transactions', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/transactions')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/octet-stream'
request.body = '"binary format of 00000000010400bed38c2aadffa348931bcb542880ff79d607afec000000000000000000000000000000c800012b0b1fff6cccd0974966dcd665835838f0985be508e1322e09fb3d751eca132c492bda720f9ef1768d14fdabed6127560ba52d5e3ac470dcb60b784e97dc88c9030200000000000516df0ba3e79792be7be5e50a370289accfc8c9e032000000000000303974657374206d656d6f00000000000000000000000000000000000000000000000000"'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

"binary format of 00000000010400bed38c2aadffa348931bcb542880ff79d607afec000000000000000000000000000000c800012b0b1fff6cccd0974966dcd665835838f0985be508e1322e09fb3d751eca132c492bda720f9ef1768d14fdabed6127560ba52d5e3ac470dcb60b784e97dc88c9030200000000000516df0ba3e79792be7be5e50a370289accfc8c9e032000000000000303974657374206d656d6f00000000000000000000000000000000000000000000000000"

"e161978626f216b2141b156ade10501207ae535fa365a13ef5d7a7c9310a09f2"

{
  "error": "transaction rejected",
  "reason": "BadNonce",
  "reason_data": {
    "actual": 4,
    "expected": 0,
    "is_origin": true,
    "principal": "ST2ZRX0K27GW0SP3GJCEMHD95TQGJMKB7G9Y0X1MH"
  },
  "txid": "caf6fd60ae05b0c2d19ef14ab6a7670b1095d117fa7c80224c74e76214d0a791"
}

Retrieve transaction details by TXID

POST

https://stacks.nownodes.io/v3/transaction/{txid}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns detailed information about a specific Stacks transaction, including the raw transaction bytes, execution result, and block metadata.

Parameters

tx_idstringrequiredpath

The transaction ID (hash) identifying the Stacks transaction.

Response

200OK

Transaction successfully retrieved

Retrieve transaction details by TXID

curl -X POST 'https://stacks.nownodes.io/v3/transaction/{txid}'

const response = await fetch('https://stacks.nownodes.io/v3/transaction/{txid}', {
  method: 'POST',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/transaction/{txid}')
request = Net::HTTP::Post.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.post('https://stacks.nownodes.io/v3/transaction/{txid}')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v3/transaction/{txid}', {
  method: 'POST',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v3/transaction/{txid}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v3/transaction/{txid}', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://stacks.nownodes.io/v3/transaction/{txid}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/transaction/{txid}')
request = Net::HTTP::Post.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

{
  "index_block_hash": "0e9db41c95f3d940483f3ad515078e8f93cf401d07fffbe09b4a9cc1313e1f71",
  "tx": "00000000010400f2bba6df751755ab9ac1df8b387d981cfe265cdf000000000020499f00000000000000b400018588430962cdc46929f7474d9bb1ba00cc61874fd8a2a1a60273bf3c4519de852632e0dbc5931509af496229124de6e45db31071b58a3726cfbf7b57850fd8b7030200000000000516fbd9a1702f4ecc44fc01f1894c72fcbb23a53ce8000000000000000100000000000000000000000000000000000000000000000000000000000000000000",
  "result": "(ok true)",
  "block_height": 5641143,
  "is_canonical": true
}

Smart Contracts

Get contract interface

GET

https://stacks.nownodes.io/v2/contracts/interface/{contract_address}/{contract_name}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get contract interface using a contract_address and contract name

Parameters

contract_addressstringrequiredpath

Stacks address

contract_namestringrequiredpath

Contract name

tipstringquery

The Stacks chain tip to query from. If tip == latest, the query will be run from the latest known tip (includes unconfirmed state).

Response

200OK

Contract interface

Get contract interface

curl -X GET 'https://stacks.nownodes.io/v2/contracts/interface/{contract_address}/{contract_name}'

const response = await fetch('https://stacks.nownodes.io/v2/contracts/interface/{contract_address}/{contract_name}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/contracts/interface/{contract_address}/{contract_name}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://stacks.nownodes.io/v2/contracts/interface/{contract_address}/{contract_name}')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v2/contracts/interface/{contract_address}/{contract_name}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v2/contracts/interface/{contract_address}/{contract_name}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v2/contracts/interface/{contract_address}/{contract_name}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://stacks.nownodes.io/v2/contracts/interface/{contract_address}/{contract_name}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/contracts/interface/{contract_address}/{contract_name}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

{
  "functions": [
    {
      "name": "get-value",
      "access": "public",
      "args": [
        {
          "name": "key",
          "type": {
            "buffer": {
              "length": 32
            }
          }
        }
      ],
      "outputs": {
        "type": {
          "response": {
            "ok": {
              "buffer": {
                "length": 32
              }
            },
            "error": "int128"
          }
        }
      }
    },
    {
      "name": "set-value",
      "access": "public",
      "args": [
        {
          "name": "key",
          "type": {
            "buffer": {
              "length": 32
            }
          }
        },
        {
          "name": "value",
          "type": {
            "buffer": {
              "length": 32
            }
          }
        }
      ],
      "outputs": {
        "type": {
          "response": {
            "ok": "uint128",
            "error": "none"
          }
        }
      }
    },
    {
      "name": "test-emit-event",
      "access": "public",
      "args": [],
      "outputs": {
        "type": {
          "response": {
            "ok": "uint128",
            "error": "none"
          }
        }
      }
    },
    {
      "name": "test-event-types",
      "access": "public",
      "args": [],
      "outputs": {
        "type": {
          "response": {
            "ok": "uint128",
            "error": "none"
          }
        }
      }
    }
  ],
  "variables": [
    {
      "name": "recipient",
      "type": "principal",
      "access": "constant"
    },
    {
      "name": "sender",
      "type": "principal",
      "access": "constant"
    }
  ],
  "maps": [
    {
      "name": "store",
      "key": [
        {
          "name": "key",
          "type": {
            "buffer": {
              "length": 32
            }
          }
        }
      ],
      "value": [
        {
          "name": "value",
          "type": {
            "buffer": {
              "length": 32
            }
          }
        }
      ]
    }
  ],
  "fungible_tokens": [
    {
      "name": "novel-token-19"
    }
  ],
  "non_fungible_tokens": [
    {
      "name": "hello-nft",
      "type": "uint128"
    }
  ]
}

Get specific data-map inside a contract

POST

https://stacks.nownodes.io/v2/map_entry/{contract_address}/{contract_name}/{map_name}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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 atom.

In the response, data is 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.

Body

application/json

Hex string serialization of the lookup key (which should be a Clarity value)

string

Parameters

contract_addressstringrequiredpath

Stacks address

contract_namestringrequiredpath

Contract name

map_namestringrequiredpath

Map name

proofintegerquery

Returns object without the proof field when set to 0

tipstringquery

The Stacks chain tip to query from. If tip == latest, the query will be run from the latest known tip (includes unconfirmed state).

Response

200OK

Success

400Bad Request

Failed loading data map

Get specific data-map inside a contract

curl -X POST 'https://stacks.nownodes.io/v2/map_entry/{contract_address}/{contract_name}/{map_name}' \
  -H 'Content-Type: application/json' \
  -d '"string"'

const response = await fetch('https://stacks.nownodes.io/v2/map_entry/{contract_address}/{contract_name}/{map_name}', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify("string"),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/map_entry/{contract_address}/{contract_name}/{map_name}')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '"string"'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = "string"

response = requests.post('https://stacks.nownodes.io/v2/map_entry/{contract_address}/{contract_name}/{map_name}', json=payload)
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v2/map_entry/{contract_address}/{contract_name}/{map_name}', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify("string"),
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v2/map_entry/{contract_address}/{contract_name}/{map_name}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest("string");
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v2/map_entry/{contract_address}/{contract_name}/{map_name}', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify("string"),
});

const data = await response.json();

import requests

payload = "string"

response = requests.post('https://stacks.nownodes.io/v2/map_entry/{contract_address}/{contract_name}/{map_name}', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/map_entry/{contract_address}/{contract_name}/{map_name}')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '"string"'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

"string"

200

{
  "data": "0x0a0c000000010a6d6f6e737465722d69640100000000000000000000000000000001",
  "proof": "0x123..."
}

Get contract source

GET

https://stacks.nownodes.io/v2/contracts/source/{contract_address}/{contract_name}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

contract_addressstringrequiredpath

Stacks address

contract_namestringrequiredpath

Contract name

proofintegerquery

Returns object without the proof field if set to 0

tipstringquery

The Stacks chain tip to query from. If tip == latest, the query will be run from the latest known tip (includes unconfirmed state).

Response

200OK

Success

Get contract source

curl -X GET 'https://stacks.nownodes.io/v2/contracts/source/{contract_address}/{contract_name}'

const response = await fetch('https://stacks.nownodes.io/v2/contracts/source/{contract_address}/{contract_name}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/contracts/source/{contract_address}/{contract_name}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://stacks.nownodes.io/v2/contracts/source/{contract_address}/{contract_name}')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v2/contracts/source/{contract_address}/{contract_name}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v2/contracts/source/{contract_address}/{contract_name}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v2/contracts/source/{contract_address}/{contract_name}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://stacks.nownodes.io/v2/contracts/source/{contract_address}/{contract_name}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/contracts/source/{contract_address}/{contract_name}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

{
  "source": "(define-constant sender 'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR)\n(define-constant recipient 'SM2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQVX8X0G)\n\n(define-fungible-token novel-token-19)\n(begin (ft-mint? novel-token-19 u12 sender))\n(begin (ft-transfer? novel-token-19 u2 sender recipient))\n\n(define-non-fungible-token hello-nft uint)\n(begin (nft-mint? hello-nft u1 sender))\n(begin (nft-mint? hello-nft u2 sender))\n(begin (nft-transfer? hello-nft u1 sender recipient))\n\n(define-public (test-emit-event)\n    (begin\n        (print \"Event! Hello world\")\n        (ok u1)))\n(begin (test-emit-event))\n\n(define-public (test-event-types)\n    (begin\n        (unwrap-panic (ft-mint? novel-token-19 u3 recipient))\n        (unwrap-panic (nft-mint? hello-nft u2 recipient))\n        (unwrap-panic (stx-transfer? u60 tx-sender 'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR))\n        (unwrap-panic (stx-burn? u20 tx-sender))\n        (ok u1)))\n\n(define-map store ((key (buff 32))) ((value (buff 32))))\n(define-public (get-value (key (buff 32)))\n    (begin\n        (match (map-get? store ((key key)))\n            entry (ok (get value entry))\n            (err 0))))\n(define-public (set-value (key (buff 32)) (value (buff 32)))\n    (begin\n        (map-set store ((key key)) ((value value)))\n        (ok u1)))",
  "publish_height": 3196,
  "proof": "0000001104060000001ec4e..."
}

Call read-only function

POST

https://stacks.nownodes.io/v2/contracts/call-read/{contract_address}/{contract_name}/{function_name}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Call a read-only public function on a given smart contract.

The smart contract and function are specified using the URL path. The arguments and the simulated tx-sender are supplied via the POST body in the following JSON format:

Body

application/json

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.

Describes representation of a Type-0 Stacks 2.0 transaction. https://github.com/stacksgov/sips/blob/main/sips/sip-005/sip-005-blocks-and-transactions.md#type-0-transferring-an-asset

senderstringrequired

The simulated tx-sender

argumentsArray<string>required

An array of hex serialized Clarity values

Parameters

contract_addressstringrequiredpath

Stacks address

contract_namestringrequiredpath

Contract name

function_namestringrequiredpath

Function name

tipstringquery

The Stacks chain tip to query from. If tip == latest, the query will be run from the latest known tip (includes unconfirmed state).

Response

200OK

Success

Call read-only function

curl -X POST 'https://stacks.nownodes.io/v2/contracts/call-read/{contract_address}/{contract_name}/{function_name}' \
  -H 'Content-Type: application/json' \
  -d '{
    "sender": "SP31DA6FTSJX2WGTZ69SFY11BH51NZMB0ZW97B5P0.get-info",
    "arguments": [
      "0x0011...",
      "0x00231..."
    ]
  }'

const response = await fetch('https://stacks.nownodes.io/v2/contracts/call-read/{contract_address}/{contract_name}/{function_name}', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "sender": "SP31DA6FTSJX2WGTZ69SFY11BH51NZMB0ZW97B5P0.get-info",
      "arguments": [
        "0x0011...",
        "0x00231..."
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/contracts/call-read/{contract_address}/{contract_name}/{function_name}')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "sender": "SP31DA6FTSJX2WGTZ69SFY11BH51NZMB0ZW97B5P0.get-info",
    "arguments": [
      "0x0011...",
      "0x00231..."
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "sender": "SP31DA6FTSJX2WGTZ69SFY11BH51NZMB0ZW97B5P0.get-info",
  "arguments": [
    "0x0011...",
    "0x00231..."
  ]
}

response = requests.post('https://stacks.nownodes.io/v2/contracts/call-read/{contract_address}/{contract_name}/{function_name}', json=payload)
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v2/contracts/call-read/{contract_address}/{contract_name}/{function_name}', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "sender": "SP31DA6FTSJX2WGTZ69SFY11BH51NZMB0ZW97B5P0.get-info",
      "arguments": [
        "0x0011...",
        "0x00231..."
      ]
    }),
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v2/contracts/call-read/{contract_address}/{contract_name}/{function_name}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "sender": "SP31DA6FTSJX2WGTZ69SFY11BH51NZMB0ZW97B5P0.get-info",
    "arguments": [
      "0x0011...",
      "0x00231..."
    ]
  });
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v2/contracts/call-read/{contract_address}/{contract_name}/{function_name}', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "sender": "SP31DA6FTSJX2WGTZ69SFY11BH51NZMB0ZW97B5P0.get-info",
      "arguments": [
        "0x0011...",
        "0x00231..."
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "sender": "SP31DA6FTSJX2WGTZ69SFY11BH51NZMB0ZW97B5P0.get-info",
  "arguments": [
    "0x0011...",
    "0x00231..."
  ]
}

response = requests.post('https://stacks.nownodes.io/v2/contracts/call-read/{contract_address}/{contract_name}/{function_name}', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/contracts/call-read/{contract_address}/{contract_name}/{function_name}')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "sender": "SP31DA6FTSJX2WGTZ69SFY11BH51NZMB0ZW97B5P0.get-info",
    "arguments": [
      "0x0011...",
      "0x00231..."
    ]
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "sender": "SP31DA6FTSJX2WGTZ69SFY11BH51NZMB0ZW97B5P0.get-info",
  "arguments": [
    "0x0011...",
    "0x00231..."
  ]
}

200

{
  "okay": true,
  "result": "0x111..."
}

{
  "okay": false,
  "cause": "Unchecked(PublicFunctionNotReadOnly(..."
}

Get trait implementation details

GET

https://stacks.nownodes.io/v2/traits/{contract_address}/{contract_name}/{trait_contract_address}/{trait_contract_name}/{trait_name}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Determine whether or not a specified trait is implemented (either explicitly or implicitly) within a given contract.

Parameters

contract_addressstringrequiredpath

Stacks address

contract_namestringrequiredpath

Contract name

trait_contract_addressstringrequiredpath

Trait Stacks address

trait_contract_namestringrequiredpath

Trait contract name

trait_namestringrequiredpath

Trait name

tipstringquery

The Stacks chain tip to query from. If tip == "latest", the query will be run from the latest known tip (includes unconfirmed state). If the tip is left unspecified, the stacks chain tip will be selected (only includes confirmed state).

Response

200OK

Success

Get trait implementation details

curl -X GET 'https://stacks.nownodes.io/v2/traits/{contract_address}/{contract_name}/{trait_contract_address}/{trait_contract_name}/{trait_name}'

const response = await fetch('https://stacks.nownodes.io/v2/traits/{contract_address}/{contract_name}/{trait_contract_address}/{trait_contract_name}/{trait_name}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/traits/{contract_address}/{contract_name}/{trait_contract_address}/{trait_contract_name}/{trait_name}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://stacks.nownodes.io/v2/traits/{contract_address}/{contract_name}/{trait_contract_address}/{trait_contract_name}/{trait_name}')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v2/traits/{contract_address}/{contract_name}/{trait_contract_address}/{trait_contract_name}/{trait_name}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v2/traits/{contract_address}/{contract_name}/{trait_contract_address}/{trait_contract_name}/{trait_name}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v2/traits/{contract_address}/{contract_name}/{trait_contract_address}/{trait_contract_name}/{trait_name}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://stacks.nownodes.io/v2/traits/{contract_address}/{contract_name}/{trait_contract_address}/{trait_contract_name}/{trait_name}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/traits/{contract_address}/{contract_name}/{trait_contract_address}/{trait_contract_name}/{trait_name}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

{
  "is_implemented": true
}

Get the MARF value for a given key

POST

https://stacks.nownodes.io/v2/clarity/marf/{clarity_marf_key}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Attempt to fetch the value of a MARF key.

In the response, data is the hex serialization of the value.

Parameters

clarity_marf_keystringrequiredpath

MARF key

proofintegerquery

Returns object without the proof field when set to 0

tipstringquery

The Stacks chain tip to query from. If tip == latest, the query will be run from the latest known tip (includes unconfirmed state).

Response

200OK

Success

400Bad Request

Failed to retrieve MARF key

Get the MARF value for a given key

curl -X POST 'https://stacks.nownodes.io/v2/clarity/marf/{clarity_marf_key}'

const response = await fetch('https://stacks.nownodes.io/v2/clarity/marf/{clarity_marf_key}', {
  method: 'POST',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/clarity/marf/{clarity_marf_key}')
request = Net::HTTP::Post.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.post('https://stacks.nownodes.io/v2/clarity/marf/{clarity_marf_key}')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v2/clarity/marf/{clarity_marf_key}', {
  method: 'POST',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v2/clarity/marf/{clarity_marf_key}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v2/clarity/marf/{clarity_marf_key}', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://stacks.nownodes.io/v2/clarity/marf/{clarity_marf_key}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/clarity/marf/{clarity_marf_key}')
request = Net::HTTP::Post.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

{
  "data": "0x0a0c000000010a6d6f6e737465722d69640100000000000000000000000000000001",
  "proof": "0x123..."
}

Get the contract metadata for the metadata key

POST

https://stacks.nownodes.io/v2/clarity/metadata/{contract_address}/{contract_name}/{clarity_metadata_key}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

Parameters

contract_addressstringrequiredpath

Stacks address

contract_namestringrequiredpath

Contract name

clarity_metadata_keystringrequiredpath

Metadata key

tipstringquery

The Stacks chain tip to query from. If tip == latest, the query will be run from the latest known tip (includes unconfirmed state).

Response

200OK

Success

400Bad Request

Failed to retrieve constant value from contract

Get the contract metadata for the metadata key

curl -X POST 'https://stacks.nownodes.io/v2/clarity/metadata/{contract_address}/{contract_name}/{clarity_metadata_key}'

const response = await fetch('https://stacks.nownodes.io/v2/clarity/metadata/{contract_address}/{contract_name}/{clarity_metadata_key}', {
  method: 'POST',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/clarity/metadata/{contract_address}/{contract_name}/{clarity_metadata_key}')
request = Net::HTTP::Post.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.post('https://stacks.nownodes.io/v2/clarity/metadata/{contract_address}/{contract_name}/{clarity_metadata_key}')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v2/clarity/metadata/{contract_address}/{contract_name}/{clarity_metadata_key}', {
  method: 'POST',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v2/clarity/metadata/{contract_address}/{contract_name}/{clarity_metadata_key}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v2/clarity/metadata/{contract_address}/{contract_name}/{clarity_metadata_key}', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://stacks.nownodes.io/v2/clarity/metadata/{contract_address}/{contract_name}/{clarity_metadata_key}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/clarity/metadata/{contract_address}/{contract_name}/{clarity_metadata_key}')
request = Net::HTTP::Post.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

{
  "data": "'{\"contract_identifier\":{...}, \"private_function_types\":{...}'"
}

Get the value of a constant inside a contract

POST

https://stacks.nownodes.io/v2/constant_val/{contract_address}/{contract_name}/{constant_name}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

Parameters

contract_addressstringrequiredpath

Stacks address

contract_namestringrequiredpath

Contract name

constant_namestringrequiredpath

Constant name

tipstringquery

The Stacks chain tip to query from. If tip == latest, the query will be run from the latest known tip (includes unconfirmed state).

Response

200OK

Success

400Bad Request

Failed to retrieve constant value from contract

Get the value of a constant inside a contract

curl -X POST 'https://stacks.nownodes.io/v2/constant_val/{contract_address}/{contract_name}/{constant_name}'

const response = await fetch('https://stacks.nownodes.io/v2/constant_val/{contract_address}/{contract_name}/{constant_name}', {
  method: 'POST',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/constant_val/{contract_address}/{contract_name}/{constant_name}')
request = Net::HTTP::Post.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.post('https://stacks.nownodes.io/v2/constant_val/{contract_address}/{contract_name}/{constant_name}')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v2/constant_val/{contract_address}/{contract_name}/{constant_name}', {
  method: 'POST',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v2/constant_val/{contract_address}/{contract_name}/{constant_name}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v2/constant_val/{contract_address}/{contract_name}/{constant_name}', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://stacks.nownodes.io/v2/constant_val/{contract_address}/{contract_name}/{constant_name}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/constant_val/{contract_address}/{contract_name}/{constant_name}')
request = Net::HTTP::Post.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

{
  "data": "0x01ce..."
}

Accounts

Get account info

GET

https://stacks.nownodes.io/v2/accounts/{principal}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

principalstringrequiredpath

Stacks address or a Contract identifier (e.g. SP31DA6FTSJX2WGTZ69SFY11BH51NZMB0ZW97B5P0.get-info)

proofintegerquery

Returns object without the proof field if set to 0

tipstringquery

The Stacks chain tip to query from. If tip == latest, the query will be run from the latest known tip (includes unconfirmed state).

Response

200OK

Success

Get account info

curl -X GET 'https://stacks.nownodes.io/v2/accounts/{principal}'

const response = await fetch('https://stacks.nownodes.io/v2/accounts/{principal}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/accounts/{principal}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://stacks.nownodes.io/v2/accounts/{principal}')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v2/accounts/{principal}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v2/accounts/{principal}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v2/accounts/{principal}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://stacks.nownodes.io/v2/accounts/{principal}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/accounts/{principal}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

{
  "balance": "0x0000000000000000000000000007a120",
  "locked": "0x0000000000000000000000000007a120",
  "unlock_height": 126,
  "nonce": 2867,
  "balance_proof": "0xabce",
  "nonce_proof": "0xabcd"
}

Fees

Get approximate fees for the given transaction

POST

https://stacks.nownodes.io/v2/fees/transaction

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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)

Body

application/json

POST request for estimated fee

transaction_payloadstringrequired

estimated_leninteger

Response

200OK

Estimated fees for the transaction

Get approximate fees for the given transaction

curl -X POST 'https://stacks.nownodes.io/v2/fees/transaction' \
  -H 'Content-Type: application/json' \
  -d '{
    "estimated_len": 350,
    "transaction_payload": "021af942874ce525e87f21bbe8c121b12fac831d02f4086765742d696e666f0b7570646174652d696e666f00000000"
  }'

const response = await fetch('https://stacks.nownodes.io/v2/fees/transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "estimated_len": 350,
      "transaction_payload": "021af942874ce525e87f21bbe8c121b12fac831d02f4086765742d696e666f0b7570646174652d696e666f00000000"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/fees/transaction')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "estimated_len": 350,
    "transaction_payload": "021af942874ce525e87f21bbe8c121b12fac831d02f4086765742d696e666f0b7570646174652d696e666f00000000"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "estimated_len": 350,
  "transaction_payload": "021af942874ce525e87f21bbe8c121b12fac831d02f4086765742d696e666f0b7570646174652d696e666f00000000"
}

response = requests.post('https://stacks.nownodes.io/v2/fees/transaction', json=payload)
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v2/fees/transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "estimated_len": 350,
      "transaction_payload": "021af942874ce525e87f21bbe8c121b12fac831d02f4086765742d696e666f0b7570646174652d696e666f00000000"
    }),
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v2/fees/transaction";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "estimated_len": 350,
    "transaction_payload": "021af942874ce525e87f21bbe8c121b12fac831d02f4086765742d696e666f0b7570646174652d696e666f00000000"
  });
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v2/fees/transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "estimated_len": 350,
      "transaction_payload": "021af942874ce525e87f21bbe8c121b12fac831d02f4086765742d696e666f0b7570646174652d696e666f00000000"
    }),
});

const data = await response.json();

import requests

payload = {
  "estimated_len": 350,
  "transaction_payload": "021af942874ce525e87f21bbe8c121b12fac831d02f4086765742d696e666f0b7570646174652d696e666f00000000"
}

response = requests.post('https://stacks.nownodes.io/v2/fees/transaction', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/fees/transaction')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "estimated_len": 350,
    "transaction_payload": "021af942874ce525e87f21bbe8c121b12fac831d02f4086765742d696e666f0b7570646174652d696e666f00000000"
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "estimated_len": 350,
  "transaction_payload": "021af942874ce525e87f21bbe8c121b12fac831d02f4086765742d696e666f0b7570646174652d696e666f00000000"
}

200

{
  "cost_scalar_change_by_byte": 0.00476837158203125,
  "estimated_cost": {
    "read_count": 19,
    "read_length": 4814,
    "runtime": 7175000,
    "write_count": 2,
    "write_length": 1020
  },
  "estimated_cost_scalar": 14,
  "estimations": [
    {
      "fee": 17,
      "fee_rate": 1.2410714285714286
    },
    {
      "fee": 125,
      "fee_rate": 8.958333333333332
    },
    {
      "fee": 140,
      "fee_rate": 10
    }
  ]
}

Get estimated fee

GET

https://stacks.nownodes.io/v2/fees/transfer

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get an estimated fee rate for STX transfer transactions. This a a fee rate / byte, and is returned as a JSON integer

Response

200OK

Success

Get estimated fee

curl -X GET 'https://stacks.nownodes.io/v2/fees/transfer'

const response = await fetch('https://stacks.nownodes.io/v2/fees/transfer', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/fees/transfer')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://stacks.nownodes.io/v2/fees/transfer')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v2/fees/transfer', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v2/fees/transfer";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v2/fees/transfer', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://stacks.nownodes.io/v2/fees/transfer')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/fees/transfer')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

Info

Get Core API info

GET

https://stacks.nownodes.io/v2/info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get Core API information

Response

200OK

Success

Get Core API info

curl -X GET 'https://stacks.nownodes.io/v2/info'

const response = await fetch('https://stacks.nownodes.io/v2/info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/info')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://stacks.nownodes.io/v2/info')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v2/info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v2/info";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v2/info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://stacks.nownodes.io/v2/info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/info')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

{
  "peer_version": 385875968,
  "pox_consensus": "17f76e597bab45646956f38dd39573085d72cbc0",
  "burn_block_height": 16,
  "stable_pox_consensus": "8e0561978fc5506b68a589c402dad97e862edb59",
  "stable_burn_block_height": 15,
  "server_version": "blockstack-core 0.0.1 => 23.0.0.0 (, release build, linux [x86_64])",
  "network_id": 2147483648,
  "parent_network_id": 3669344250,
  "stacks_tip_height": 15,
  "stacks_tip": "b1807a2d3f7f8c7922f7c1d60d7c34145ade05d789640dc7dc9ec1021e07bb54",
  "stacks_tip_consensus_hash": "17f76e597bab45646956f38dd39573085d72cbc0",
  "unanchored_tip": "0000000000000000000000000000000000000000000000000000000000000000",
  "tenure_height": 523,
  "exit_at_block_height": null,
  "is_fully_synced": false
}

Get PoX details

GET

https://stacks.nownodes.io/v2/pox

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get Proof of Transfer (PoX) information. Can be used for Stacking.

Parameters

tipstringquery

The Stacks chain tip to query from. If tip == latest, the query will be run from the latest known tip (includes unconfirmed state).

Response

200OK

Success

Get PoX details

curl -X GET 'https://stacks.nownodes.io/v2/pox'

const response = await fetch('https://stacks.nownodes.io/v2/pox', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/pox')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://stacks.nownodes.io/v2/pox')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v2/pox', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v2/pox";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v2/pox', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://stacks.nownodes.io/v2/pox')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v2/pox')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

{
  "contract_id": "SP000000000000000000002Q6VF78.pox",
  "pox_activation_threshold_ustx": 52329761604388,
  "first_burnchain_block_height": 666050,
  "current_burnchain_block_height": 812345,
  "prepare_phase_block_length": 100,
  "reward_phase_block_length": 2000,
  "reward_slots": 4000,
  "rejection_fraction": 25,
  "total_liquid_supply_ustx": 1046595232087772,
  "current_cycle": {
    "id": 2,
    "min_threshold_ustx": 70000000000,
    "stacked_ustx": 202157971547640,
    "is_pox_active": true
  },
  "next_cycle": {
    "id": 3,
    "min_threshold_ustx": 70000000000,
    "min_increment_ustx": 52329761604,
    "stacked_ustx": 162057034977640,
    "prepare_phase_start_block_height": 672250,
    "blocks_until_prepare_phase": 407,
    "reward_phase_start_block_height": 672350,
    "blocks_until_reward_phase": 507,
    "ustx_until_pox_rejection": 261648808021925
  },
  "min_amount_ustx": 70000000000,
  "prepare_cycle_length": 100,
  "reward_cycle_id": 2,
  "reward_cycle_length": 2100,
  "rejection_votes_left_required": 261648808021925,
  "next_reward_cycle_in": 507,
  "contract_versions": [
    {
      "contract_id": "SP000000000000000000002Q6VF78.pox",
      "activation_burnchain_block_height": 666050,
      "first_reward_cycle_id": 0
    },
    {
      "contract_id": "SP000000000000000000002Q6VF78.pox-2",
      "activation_burnchain_block_height": 712345,
      "first_reward_cycle_id": 123
    }
  ]
}

Mining

Validate a proposed Stacks block

POST

https://stacks.nownodes.io/v3/block_proposal

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Used by stackers to validate a proposed Stacks block from a miner.

This API endpoint requires a basic Authorization header.

Body

application/json

Response

202Accepted

Block proposal has been accepted for processing. The result will be returned via the event observer.

400Bad Request

Endpoint not enabled.

401Unauthorized

Unauthorized.

429Too Many Requests

There is an ongoing proposal validation being processed, the new request cannot be accepted until the prior request has been processed.

Validate a proposed Stacks block

curl -X POST 'https://stacks.nownodes.io/v3/block_proposal' \
  -H 'Content-Type: application/json' \
  -d '{
    "block": "00000000000000001f00000000000927c08fb5ae5bf80e39e4168f6a3fddb0407a069d21ee68465e6856393254d2a66194f44bb01070666d5effcfb2436e209a75878fe80a04b4258a8cd34ab97c38a8dde331a2a509dd7e4b90590726866172cc138c18e80567737667f55d3f9817ce4714c91d1adfd36101141829dc0b5ea0c4944668c0005ddb6f9e2718f60014f21932a42a36ffaf58e88e77b217b2af366c15dd59e6b136ca773729832dcfc5875ec0830d04012dd5a4fa77a196646ea2b356289116fd02558c034b62d63f8a65bdd20d7ffc3fec6c266cd974be776a9e92759b90f288dcc2525b6b6bd5622c5f02e0922440e9ad1095c19b4467fd94566caa9755669d8e0000000180800000000400f64081ae6209dce9245753a4f764d6f168aae1af00000000000000000000000000000064000041dbcc7391991c1a18371eb49b879240247a3ec7f281328f53976c1218ffd65421dbb101e59370e2c972b29f48dc674b2de5e1b65acbd41d5d2689124d42c16c01010000000000051a346048df62be3a52bb6236e11394e8600229e27b000000000000271000000000000000000000000000000000000000000000000000000000000000000000",
    "chain_id": 2147483648
  }'

const response = await fetch('https://stacks.nownodes.io/v3/block_proposal', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "block": "00000000000000001f00000000000927c08fb5ae5bf80e39e4168f6a3fddb0407a069d21ee68465e6856393254d2a66194f44bb01070666d5effcfb2436e209a75878fe80a04b4258a8cd34ab97c38a8dde331a2a509dd7e4b90590726866172cc138c18e80567737667f55d3f9817ce4714c91d1adfd36101141829dc0b5ea0c4944668c0005ddb6f9e2718f60014f21932a42a36ffaf58e88e77b217b2af366c15dd59e6b136ca773729832dcfc5875ec0830d04012dd5a4fa77a196646ea2b356289116fd02558c034b62d63f8a65bdd20d7ffc3fec6c266cd974be776a9e92759b90f288dcc2525b6b6bd5622c5f02e0922440e9ad1095c19b4467fd94566caa9755669d8e0000000180800000000400f64081ae6209dce9245753a4f764d6f168aae1af00000000000000000000000000000064000041dbcc7391991c1a18371eb49b879240247a3ec7f281328f53976c1218ffd65421dbb101e59370e2c972b29f48dc674b2de5e1b65acbd41d5d2689124d42c16c01010000000000051a346048df62be3a52bb6236e11394e8600229e27b000000000000271000000000000000000000000000000000000000000000000000000000000000000000",
      "chain_id": 2147483648
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/block_proposal')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "block": "00000000000000001f00000000000927c08fb5ae5bf80e39e4168f6a3fddb0407a069d21ee68465e6856393254d2a66194f44bb01070666d5effcfb2436e209a75878fe80a04b4258a8cd34ab97c38a8dde331a2a509dd7e4b90590726866172cc138c18e80567737667f55d3f9817ce4714c91d1adfd36101141829dc0b5ea0c4944668c0005ddb6f9e2718f60014f21932a42a36ffaf58e88e77b217b2af366c15dd59e6b136ca773729832dcfc5875ec0830d04012dd5a4fa77a196646ea2b356289116fd02558c034b62d63f8a65bdd20d7ffc3fec6c266cd974be776a9e92759b90f288dcc2525b6b6bd5622c5f02e0922440e9ad1095c19b4467fd94566caa9755669d8e0000000180800000000400f64081ae6209dce9245753a4f764d6f168aae1af00000000000000000000000000000064000041dbcc7391991c1a18371eb49b879240247a3ec7f281328f53976c1218ffd65421dbb101e59370e2c972b29f48dc674b2de5e1b65acbd41d5d2689124d42c16c01010000000000051a346048df62be3a52bb6236e11394e8600229e27b000000000000271000000000000000000000000000000000000000000000000000000000000000000000",
    "chain_id": 2147483648
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

payload = {
  "block": "00000000000000001f00000000000927c08fb5ae5bf80e39e4168f6a3fddb0407a069d21ee68465e6856393254d2a66194f44bb01070666d5effcfb2436e209a75878fe80a04b4258a8cd34ab97c38a8dde331a2a509dd7e4b90590726866172cc138c18e80567737667f55d3f9817ce4714c91d1adfd36101141829dc0b5ea0c4944668c0005ddb6f9e2718f60014f21932a42a36ffaf58e88e77b217b2af366c15dd59e6b136ca773729832dcfc5875ec0830d04012dd5a4fa77a196646ea2b356289116fd02558c034b62d63f8a65bdd20d7ffc3fec6c266cd974be776a9e92759b90f288dcc2525b6b6bd5622c5f02e0922440e9ad1095c19b4467fd94566caa9755669d8e0000000180800000000400f64081ae6209dce9245753a4f764d6f168aae1af00000000000000000000000000000064000041dbcc7391991c1a18371eb49b879240247a3ec7f281328f53976c1218ffd65421dbb101e59370e2c972b29f48dc674b2de5e1b65acbd41d5d2689124d42c16c01010000000000051a346048df62be3a52bb6236e11394e8600229e27b000000000000271000000000000000000000000000000000000000000000000000000000000000000000",
  "chain_id": 2147483648
}

response = requests.post('https://stacks.nownodes.io/v3/block_proposal', json=payload)
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v3/block_proposal', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "block": "00000000000000001f00000000000927c08fb5ae5bf80e39e4168f6a3fddb0407a069d21ee68465e6856393254d2a66194f44bb01070666d5effcfb2436e209a75878fe80a04b4258a8cd34ab97c38a8dde331a2a509dd7e4b90590726866172cc138c18e80567737667f55d3f9817ce4714c91d1adfd36101141829dc0b5ea0c4944668c0005ddb6f9e2718f60014f21932a42a36ffaf58e88e77b217b2af366c15dd59e6b136ca773729832dcfc5875ec0830d04012dd5a4fa77a196646ea2b356289116fd02558c034b62d63f8a65bdd20d7ffc3fec6c266cd974be776a9e92759b90f288dcc2525b6b6bd5622c5f02e0922440e9ad1095c19b4467fd94566caa9755669d8e0000000180800000000400f64081ae6209dce9245753a4f764d6f168aae1af00000000000000000000000000000064000041dbcc7391991c1a18371eb49b879240247a3ec7f281328f53976c1218ffd65421dbb101e59370e2c972b29f48dc674b2de5e1b65acbd41d5d2689124d42c16c01010000000000051a346048df62be3a52bb6236e11394e8600229e27b000000000000271000000000000000000000000000000000000000000000000000000000000000000000",
      "chain_id": 2147483648
    }),
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v3/block_proposal";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({
    "block": "00000000000000001f00000000000927c08fb5ae5bf80e39e4168f6a3fddb0407a069d21ee68465e6856393254d2a66194f44bb01070666d5effcfb2436e209a75878fe80a04b4258a8cd34ab97c38a8dde331a2a509dd7e4b90590726866172cc138c18e80567737667f55d3f9817ce4714c91d1adfd36101141829dc0b5ea0c4944668c0005ddb6f9e2718f60014f21932a42a36ffaf58e88e77b217b2af366c15dd59e6b136ca773729832dcfc5875ec0830d04012dd5a4fa77a196646ea2b356289116fd02558c034b62d63f8a65bdd20d7ffc3fec6c266cd974be776a9e92759b90f288dcc2525b6b6bd5622c5f02e0922440e9ad1095c19b4467fd94566caa9755669d8e0000000180800000000400f64081ae6209dce9245753a4f764d6f168aae1af00000000000000000000000000000064000041dbcc7391991c1a18371eb49b879240247a3ec7f281328f53976c1218ffd65421dbb101e59370e2c972b29f48dc674b2de5e1b65acbd41d5d2689124d42c16c01010000000000051a346048df62be3a52bb6236e11394e8600229e27b000000000000271000000000000000000000000000000000000000000000000000000000000000000000",
    "chain_id": 2147483648
  });
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v3/block_proposal', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "block": "00000000000000001f00000000000927c08fb5ae5bf80e39e4168f6a3fddb0407a069d21ee68465e6856393254d2a66194f44bb01070666d5effcfb2436e209a75878fe80a04b4258a8cd34ab97c38a8dde331a2a509dd7e4b90590726866172cc138c18e80567737667f55d3f9817ce4714c91d1adfd36101141829dc0b5ea0c4944668c0005ddb6f9e2718f60014f21932a42a36ffaf58e88e77b217b2af366c15dd59e6b136ca773729832dcfc5875ec0830d04012dd5a4fa77a196646ea2b356289116fd02558c034b62d63f8a65bdd20d7ffc3fec6c266cd974be776a9e92759b90f288dcc2525b6b6bd5622c5f02e0922440e9ad1095c19b4467fd94566caa9755669d8e0000000180800000000400f64081ae6209dce9245753a4f764d6f168aae1af00000000000000000000000000000064000041dbcc7391991c1a18371eb49b879240247a3ec7f281328f53976c1218ffd65421dbb101e59370e2c972b29f48dc674b2de5e1b65acbd41d5d2689124d42c16c01010000000000051a346048df62be3a52bb6236e11394e8600229e27b000000000000271000000000000000000000000000000000000000000000000000000000000000000000",
      "chain_id": 2147483648
    }),
});

const data = await response.json();

import requests

payload = {
  "block": "00000000000000001f00000000000927c08fb5ae5bf80e39e4168f6a3fddb0407a069d21ee68465e6856393254d2a66194f44bb01070666d5effcfb2436e209a75878fe80a04b4258a8cd34ab97c38a8dde331a2a509dd7e4b90590726866172cc138c18e80567737667f55d3f9817ce4714c91d1adfd36101141829dc0b5ea0c4944668c0005ddb6f9e2718f60014f21932a42a36ffaf58e88e77b217b2af366c15dd59e6b136ca773729832dcfc5875ec0830d04012dd5a4fa77a196646ea2b356289116fd02558c034b62d63f8a65bdd20d7ffc3fec6c266cd974be776a9e92759b90f288dcc2525b6b6bd5622c5f02e0922440e9ad1095c19b4467fd94566caa9755669d8e0000000180800000000400f64081ae6209dce9245753a4f764d6f168aae1af00000000000000000000000000000064000041dbcc7391991c1a18371eb49b879240247a3ec7f281328f53976c1218ffd65421dbb101e59370e2c972b29f48dc674b2de5e1b65acbd41d5d2689124d42c16c01010000000000051a346048df62be3a52bb6236e11394e8600229e27b000000000000271000000000000000000000000000000000000000000000000000000000000000000000",
  "chain_id": 2147483648
}

response = requests.post('https://stacks.nownodes.io/v3/block_proposal', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/block_proposal')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "block": "00000000000000001f00000000000927c08fb5ae5bf80e39e4168f6a3fddb0407a069d21ee68465e6856393254d2a66194f44bb01070666d5effcfb2436e209a75878fe80a04b4258a8cd34ab97c38a8dde331a2a509dd7e4b90590726866172cc138c18e80567737667f55d3f9817ce4714c91d1adfd36101141829dc0b5ea0c4944668c0005ddb6f9e2718f60014f21932a42a36ffaf58e88e77b217b2af366c15dd59e6b136ca773729832dcfc5875ec0830d04012dd5a4fa77a196646ea2b356289116fd02558c034b62d63f8a65bdd20d7ffc3fec6c266cd974be776a9e92759b90f288dcc2525b6b6bd5622c5f02e0922440e9ad1095c19b4467fd94566caa9755669d8e0000000180800000000400f64081ae6209dce9245753a4f764d6f168aae1af00000000000000000000000000000064000041dbcc7391991c1a18371eb49b879240247a3ec7f281328f53976c1218ffd65421dbb101e59370e2c972b29f48dc674b2de5e1b65acbd41d5d2689124d42c16c01010000000000051a346048df62be3a52bb6236e11394e8600229e27b000000000000271000000000000000000000000000000000000000000000000000000000000000000000",
    "chain_id": 2147483648
  }'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

Request Body

{
  "block": "00000000000000001f00000000000927c08fb5ae5bf80e39e4168f6a3fddb0407a069d21ee68465e6856393254d2a66194f44bb01070666d5effcfb2436e209a75878fe80a04b4258a8cd34ab97c38a8dde331a2a509dd7e4b90590726866172cc138c18e80567737667f55d3f9817ce4714c91d1adfd36101141829dc0b5ea0c4944668c0005ddb6f9e2718f60014f21932a42a36ffaf58e88e77b217b2af366c15dd59e6b136ca773729832dcfc5875ec0830d04012dd5a4fa77a196646ea2b356289116fd02558c034b62d63f8a65bdd20d7ffc3fec6c266cd974be776a9e92759b90f288dcc2525b6b6bd5622c5f02e0922440e9ad1095c19b4467fd94566caa9755669d8e0000000180800000000400f64081ae6209dce9245753a4f764d6f168aae1af00000000000000000000000000000064000041dbcc7391991c1a18371eb49b879240247a3ec7f281328f53976c1218ffd65421dbb101e59370e2c972b29f48dc674b2de5e1b65acbd41d5d2689124d42c16c01010000000000051a346048df62be3a52bb6236e11394e8600229e27b000000000000271000000000000000000000000000000000000000000000000000000000000000000000",
  "chain_id": 2147483648
}

{
  "message": "Block proposal is processing, result will be returned via the event observer",
  "result": "Accepted"
}

{
  "message": "Could not process block proposal request: Proposal currently being evaluated",
  "result": "Error"
}

Fetch the stacker and signer set information for a given cycle.

GET

https://stacks.nownodes.io/v3/stacker_set/{cycle_number}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Used to get stacker and signer set information for a given cycle.

This will only return information for cycles started in Epoch-2.5 where PoX-4 was active and subsequent cycles.

Parameters

cycle_numberintegerrequiredpath

reward cycle number

Response

200OK

Information for the given reward cycle

400Bad Request

Could not fetch the given reward set

Fetch the stacker and signer set information for a given cycle.

curl -X GET 'https://stacks.nownodes.io/v3/stacker_set/{cycle_number}'

const response = await fetch('https://stacks.nownodes.io/v3/stacker_set/{cycle_number}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/stacker_set/{cycle_number}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://stacks.nownodes.io/v3/stacker_set/{cycle_number}')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v3/stacker_set/{cycle_number}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v3/stacker_set/{cycle_number}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v3/stacker_set/{cycle_number}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://stacks.nownodes.io/v3/stacker_set/{cycle_number}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/stacker_set/{cycle_number}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "stacker_set": {
    "rewarded_addresses": [
      {
        "Standard": [
          {
            "bytes": "dc5f18421006ee2b98ab972edfa7268a981e3f00",
            "version": 26
          },
          "SerializeP2PKH"
        ]
      }
    ],
    "signers": [
      {
        "signing_key": "02d0a27e4f1bf186b4391eecfcc4d4a0d403684ad089b477b8548a69dd6378bf26",
        "slots": 1,
        "stacked_amt": 2143020000000000
      }
    ],
    "start_cycle_state": {
      "missed_reward_slots": []
    }
  }
}

{
  "response": "error",
  "err_msg": "Could not read reward set. Prepare phase may not have started for this cycle yet. Cycle = 22, Err = PoXAnchorBlockRequired"
}

Blocks

Fetch a Nakamoto block

GET

https://stacks.nownodes.io/v3/blocks/{block_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Fetch a Nakamoto block by its index block hash.

Parameters

block_idstringrequiredpath

The block's ID hash

Response

200OK

The raw SIP-003-encoded block will be returned.

404Not Found

The block could not be found

Fetch a Nakamoto block

curl -X GET 'https://stacks.nownodes.io/v3/blocks/{block_id}'

const response = await fetch('https://stacks.nownodes.io/v3/blocks/{block_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/blocks/{block_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://stacks.nownodes.io/v3/blocks/{block_id}')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v3/blocks/{block_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v3/blocks/{block_id}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v3/blocks/{block_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://stacks.nownodes.io/v3/blocks/{block_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/blocks/{block_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

"binary"

Fetch a Nakamoto block by its height and optional tip

GET

https://stacks.nownodes.io/v3/blocks/height/{block_height}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Fetch a Nakamoto block by its height and optional tip.

Parameters

block_heightintegerrequiredpath

The block's height

tipstringquery

The Stacks chain tip to query from. If tip == latest or empty, the query will be run from the latest known tip.

Response

200OK

The raw SIP-003-encoded block will be returned.

404Not Found

The block could not be found

Fetch a Nakamoto block by its height and optional tip

curl -X GET 'https://stacks.nownodes.io/v3/blocks/height/{block_height}'

const response = await fetch('https://stacks.nownodes.io/v3/blocks/height/{block_height}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/blocks/height/{block_height}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://stacks.nownodes.io/v3/blocks/height/{block_height}')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v3/blocks/height/{block_height}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v3/blocks/height/{block_height}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v3/blocks/height/{block_height}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://stacks.nownodes.io/v3/blocks/height/{block_height}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/blocks/height/{block_height}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

"binary"

Simulate a block

POST

https://stacks.nownodes.io/v3/blocks/simulate/{block_hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Simulates the processing of a block identified by its hash. The node will apply the block's transactions to the current chain state in a temporary context and return the resulting block information, including the expected state changes and fees, without persisting anything to the actual chain.

Parameters

block_hashstringrequiredpath

The hex-encoded hash of the block to simulate (as typically returned by the miner or proposer).

Response

200OK

Successful simulation response containing the simulated block details.

Simulate a block

curl -X POST 'https://stacks.nownodes.io/v3/blocks/simulate/{block_hash}'

const response = await fetch('https://stacks.nownodes.io/v3/blocks/simulate/{block_hash}', {
  method: 'POST',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/blocks/simulate/{block_hash}')
request = Net::HTTP::Post.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.post('https://stacks.nownodes.io/v3/blocks/simulate/{block_hash}')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v3/blocks/simulate/{block_hash}', {
  method: 'POST',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v3/blocks/simulate/{block_hash}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v3/blocks/simulate/{block_hash}', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://stacks.nownodes.io/v3/blocks/simulate/{block_hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/blocks/simulate/{block_hash}')
request = Net::HTTP::Post.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

{
  "block_id": "704c38016d2cd14a94bc91095487a85e205b05cee4ae3c2c54621bac63af0684",
  "block_hash": "946ac86cdc03868f365290935f3febda39a42e2f9474e0d461ef332776b7cf8d",
  "block_height": 7352933,
  "parent_block_id": "d1bf095126614db563cb5157803d8d82054139adb2bbe2a2d8689a506ea9ae90",
  "consensus_hash": "e207d4238760d133e52790da76e2dd59567f9b5e",
  "fees": 0,
  "tx_merkle_root": "0000000000000000000000000000000000000000000000000000000000000000",
  "state_index_root": "48f8080ab57712ff4a7018ab4a5446252d51102f255df9c3e4624a2ce3992981",
  "timestamp": 1774546381,
  "miner_signature": "01a708d36bc72a31f6618394e275d2a6a323781000870d7075173ec70746d2e96445623e94708650fc03751e0fbdbf0a8b5d4574a2df2c0e8b4137e9edd89c4bc8",
  "signer_signature": [],
  "transactions": [],
  "valid_merkle_root": false
}

Fetch metadata about the ongoing Nakamoto tenure

GET

https://stacks.nownodes.io/v3/tenures/info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Fetch metadata about the ongoing Nakamoto tenure. This information is sufficient to obtain and authenticate the highest complete tenure, as well as obtain new tenure blocks.

Response

200OK

Metadata about the ongoing tenure

Fetch metadata about the ongoing Nakamoto tenure

curl -X GET 'https://stacks.nownodes.io/v3/tenures/info'

const response = await fetch('https://stacks.nownodes.io/v3/tenures/info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/tenures/info')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://stacks.nownodes.io/v3/tenures/info')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v3/tenures/info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v3/tenures/info";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v3/tenures/info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://stacks.nownodes.io/v3/tenures/info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/tenures/info')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

{
  "consensus_hash": "4c5a49be0e34dc603b66f090fd07d28a2f76a2ad",
  "parent_consensus_hash": "fa8a04af41957499afdd4082b9b702ffca9a4370",
  "parent_tenure_start_block_id": "0cfec8433849d353ad6b2fe1173da143e3d4a3ab452588a14eb074d0181ac202",
  "reward_cycle": 8,
  "tenure_start_block_id": "0425099d51547c714df6a7864c040c1a605b198ff07f71d19a823139c88a35f8",
  "tip_block_id": "52d64f5e47abc7666c4fed3fe850f381f93f2d588ee2a92a4e07b44f14588d5e",
  "tip_height": 416
}

Fetch a sequence of Nakamoto blocks in a tenure

GET

https://stacks.nownodes.io/v3/tenures/{block_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Fetch a sequence of Nakamoto blocks in a tenure. The blocks will be served in order from highest to lowest. The blocks will be encoded in their SIP-003 wire format, and concatenated together.

Parameters

block_idstringrequiredpath

The tenure-start block ID of the tenure to query

stopstringquery

The block ID hash of the highest block in this tenure that is already known to the caller. Neither the corresponding block nor any of its ancestors will be served. This is used to fetch tenure blocks that the caller does not have.

Response

200OK

SIP-003-encoded Nakamoto blocks, concatenated together

Fetch a sequence of Nakamoto blocks in a tenure

curl -X GET 'https://stacks.nownodes.io/v3/tenures/{block_id}'

const response = await fetch('https://stacks.nownodes.io/v3/tenures/{block_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/tenures/{block_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://stacks.nownodes.io/v3/tenures/{block_id}')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v3/tenures/{block_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v3/tenures/{block_id}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v3/tenures/{block_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://stacks.nownodes.io/v3/tenures/{block_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/tenures/{block_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

"binary"

Fetch information about evaluated burnchain blocks (i.e., sortitions).

GET

https://stacks.nownodes.io/v3/sortitions/{lookup_kind}/{lookup}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Fetch sortition information about a burnchain block. If the lookup_kind and lookup parameters are empty, it will return information about the latest burn block.

Parameters

lookup_kindstringpath

The style of lookup that should be performed. If not given, the most recent burn block processed will be returned. Otherwise, the lookup_kind should be one of the following strings:

consensus - find the burn block using the consensus hash supplied in the lookup field.
burn_height - find the burn block using the burn block height supplied in the lookup field.
burn - find the burn block using the burn block hash supplied in the lookup field.
latest_and_last - return information about the latest burn block with a winning miner and the previous such burn block

lookupstringpath

The value to use for the lookup if lookup_kind is consensus, burn_height, or burn

Response

200OK

Information for the burn block or in the case of latest_and_last, multiple burn blocks

Fetch information about evaluated burnchain blocks (i.e., sortitions).

curl -X GET 'https://stacks.nownodes.io/v3/sortitions/{lookup_kind}/{lookup}'

const response = await fetch('https://stacks.nownodes.io/v3/sortitions/{lookup_kind}/{lookup}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/sortitions/{lookup_kind}/{lookup}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://stacks.nownodes.io/v3/sortitions/{lookup_kind}/{lookup}')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v3/sortitions/{lookup_kind}/{lookup}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v3/sortitions/{lookup_kind}/{lookup}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v3/sortitions/{lookup_kind}/{lookup}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://stacks.nownodes.io/v3/sortitions/{lookup_kind}/{lookup}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/sortitions/{lookup_kind}/{lookup}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

A single element list is returned when just one sortition is requested

[
  {
    "burn_block_hash": "0x046f54cd1924a5d80fc3b8186d0334b7521acae90f9e136e2bee680c720d0e83",
    "burn_block_height": 231,
    "burn_header_timestamp": 1726797570,
    "sortition_id": "0x8a5116b7b4306dc4f6db290d1adfff9e1347f3e921bb793fc4c33e2ff05056e2",
    "parent_sortition_id": "0xdaf479110cf859e58c56b6ae941f8a14e7c7992c57027183dfbda4a4b820897c",
    "consensus_hash": "0x8d2c51db737597a93191f49bcdc9c7bb44b90892",
    "was_sortition": true,
    "miner_pk_hash160": "0x6bc51b33e9f3626944eb879147e18111581f8f9b",
    "stacks_parent_ch": "0x697357c72da55b759b1d6b721676c92c69f0b490",
    "last_sortition_ch": "0x697357c72da55b759b1d6b721676c92c69f0b490",
    "committed_block_hash": "0xeea47d6d639c565027110e192e308fb11656183d5c077bcd718d830652800183",
    "vrf_seed": "0x48b754acc291a5bfad1354ee19bbc471f14af2b21dc7eccc0f929bd16798defe"
  }
]

Sortition information about the latest burn block with a winning miner, and the previous such burn block.

[
  {
    "burn_block_hash": "0x046f54cd1924a5d80fc3b8186d0334b7521acae90f9e136e2bee680c720d0e83",
    "burn_block_height": 231,
    "burn_header_timestamp": 1726797570,
    "sortition_id": "0x8a5116b7b4306dc4f6db290d1adfff9e1347f3e921bb793fc4c33e2ff05056e2",
    "parent_sortition_id": "0xdaf479110cf859e58c56b6ae941f8a14e7c7992c57027183dfbda4a4b820897c",
    "consensus_hash": "0x8d2c51db737597a93191f49bcdc9c7bb44b90892",
    "was_sortition": true,
    "miner_pk_hash160": "0x6bc51b33e9f3626944eb879147e18111581f8f9b",
    "stacks_parent_ch": "0x697357c72da55b759b1d6b721676c92c69f0b490",
    "last_sortition_ch": "0x697357c72da55b759b1d6b721676c92c69f0b490",
    "committed_block_hash": "0xeea47d6d639c565027110e192e308fb11656183d5c077bcd718d830652800183"
  },
  {
    "burn_block_hash": "0x496ff02cb63a4850d0bdee5fab69284b6eb0392b4538e1c462f82362c5becfa4",
    "burn_block_height": 230,
    "burn_header_timestamp": 1726797570,
    "sortition_id": "0xdaf479110cf859e58c56b6ae941f8a14e7c7992c57027183dfbda4a4b820897c",
    "parent_sortition_id": "0xf9058692055cbd879d7f71e566e44b905a887b2b182407ed596b5d6499ceae2a",
    "consensus_hash": "0x697357c72da55b759b1d6b721676c92c69f0b490",
    "was_sortition": true,
    "miner_pk_hash160": "0x6bc51b33e9f3626944eb879147e18111581f8f9b",
    "stacks_parent_ch": "0xf7d1bd7d9d5c5a5c368402b6ef9510bd014d70f7",
    "last_sortition_ch": "0xf7d1bd7d9d5c5a5c368402b6ef9510bd014d70f7",
    "committed_block_hash": "0x36ee5f7f7271de1c1d4cd830e36320b51e01605547621267ae6e9b4e9b10f95e"
  }
]

Get number of blocks signed by signer during a given reward cycle

GET

https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get number of blocks signed by signer during a given reward cycle

Parameters

signerstringrequiredpath

Hex-encoded compressed Secp256k1 public key of signer

cycle_numberintegerrequiredpath

Reward cycle number

Response

200OK

Number of blocks signed

Get number of blocks signed by signer during a given reward cycle

curl -X GET 'https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}'

const response = await fetch('https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

Get tenure blocks by burn block hash

GET

https://stacks.nownodes.io/v3/tenures/blocks/hash/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information about Stacks blocks that correspond to a specific Bitcoin burn block hash. Tenures represent the relationship between Stacks blocks and Bitcoin blocks in the Proof of Transfer (PoX) consensus.

Parameters

hashstringrequiredpath

Bitcoin burn block hash in hex format. This is the hash of the Bitcoin block that mined the Stacks blocks.

Response

200OK

Successful response with tenure blocks information

400Bad Request

Bad request - invalid burn block hash format

404Not Found

Tenure not found for the specified burn block hash

500Internal Server Error

Internal server error

Get tenure blocks by burn block hash

curl -X GET 'https://stacks.nownodes.io/v3/tenures/blocks/hash/{hash}'

const response = await fetch('https://stacks.nownodes.io/v3/tenures/blocks/hash/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/tenures/blocks/hash/{hash}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://stacks.nownodes.io/v3/tenures/blocks/hash/{hash}')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v3/tenures/blocks/hash/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v3/tenures/blocks/hash/{hash}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v3/tenures/blocks/hash/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://stacks.nownodes.io/v3/tenures/blocks/hash/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/tenures/blocks/hash/{hash}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "consensus_hash": "41f41ef8fdd222aa0214d6c519374a9500188dbb",
  "burn_block_height": 919368,
  "burn_block_hash": "00000000000000000000bee5d3c310bc8fb7f99092a2d2e610139f641267a6f3",
  "stacks_blocks": [
    {
      "block_id": "8d6771e00f70f6ac306a1f8c5c36dc33c52e863c4e0c273b8b2ee94e5d400578",
      "header_type": "nakamoto",
      "block_hash": "f4d522a4b5929a76d04af8eba83e720479f972a3a28a146586ddebe5acafcd33",
      "parent_block_id": "b3b1d40ea3d34a4fc904986f018434a18ef42f807405a40786a78645a428fbeb",
      "height": 4222539
    }
  ]
}

{
  "error": "Invalid burn block hash format",
  "code": "invalid_hash_format"
}

{
  "error": "Tenure not found for burn block hash",
  "code": "tenure_not_found"
}

{
  "error": "Internal server error while fetching tenure data",
  "code": "internal_server_error"
}

Get tenure blocks by burn block height

GET

https://stacks.nownodes.io/v3/tenures/blocks/height/{height}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information about Stacks blocks that correspond to a specific Bitcoin burn block height. Tenures represent the relationship between Stacks blocks and Bitcoin blocks in the Proof of Transfer (PoX) consensus.

Parameters

heightinteger>= 0requiredpath

Bitcoin burn block height (block number in the Bitcoin blockchain). This specifies the position of the Bitcoin block in the chain.

Response

200OK

Successful response with tenure blocks information

400Bad Request

Bad request - invalid burn block height

404Not Found

Tenure not found for the specified burn block height

500Internal Server Error

Internal server error

Get tenure blocks by burn block height

curl -X GET 'https://stacks.nownodes.io/v3/tenures/blocks/height/{height}'

const response = await fetch('https://stacks.nownodes.io/v3/tenures/blocks/height/{height}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/tenures/blocks/height/{height}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://stacks.nownodes.io/v3/tenures/blocks/height/{height}')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v3/tenures/blocks/height/{height}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v3/tenures/blocks/height/{height}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v3/tenures/blocks/height/{height}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://stacks.nownodes.io/v3/tenures/blocks/height/{height}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/tenures/blocks/height/{height}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "consensus_hash": "51g52fg9gdd333bb0325e7d629485b9600299ecc",
  "burn_block_height": 919652,
  "burn_block_hash": "0000000000000000000123e5d3c310bc8fb7f99092a2d2e610139f641267a6f4",
  "stacks_blocks": [
    {
      "block_id": "9e7882f11g81g7bd417b2g9d6c47ed44d63f974c5e1d284597c7eea5e511079",
      "header_type": "nakamoto",
      "block_hash": "g5e633b5c683b76e15bf9fcb83f8305908g084b4b39b157687eefc6bdafde344",
      "parent_block_id": "c4c2e51fb4e45b5gd015a997129545b29ff53g918506b50897b89756b539gcec",
      "height": 4222650
    }
  ]
}

{
  "error": "Invalid burn block height",
  "code": "invalid_height"
}

{
  "error": "Tenure not found for burn block height",
  "code": "tenure_not_found"
}

{
  "error": "Internal server error while fetching tenure data",
  "code": "internal_server_error"
}

Get tip metadata for a specific consensus hash

GET

https://stacks.nownodes.io/v3/tenures/tip_metadata/{consensus_hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the anchored header and burn view for the specified consensus hash.

Parameters

consensus_hashstringrequiredpath

Consensus hash identifying the block

Response

200OK

Successful response

Get tip metadata for a specific consensus hash

curl -X GET 'https://stacks.nownodes.io/v3/tenures/tip_metadata/{consensus_hash}'

const response = await fetch('https://stacks.nownodes.io/v3/tenures/tip_metadata/{consensus_hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/tenures/tip_metadata/{consensus_hash}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://stacks.nownodes.io/v3/tenures/tip_metadata/{consensus_hash}')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v3/tenures/tip_metadata/{consensus_hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v3/tenures/tip_metadata/{consensus_hash}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v3/tenures/tip_metadata/{consensus_hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://stacks.nownodes.io/v3/tenures/tip_metadata/{consensus_hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/tenures/tip_metadata/{consensus_hash}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

{
  "anchored_header": {
    "Nakamoto": {
      "version": 0,
      "chain_length": 5859779,
      "burn_spent": 431131502048,
      "consensus_hash": "76aadfcfc5322c035ad7006e81810a43dbf52abf",
      "parent_block_id": "fc2c589ed7b6124c0a86862fb606a27bdb03ebf53f00d44bf8a8ea18d54c1487",
      "tx_merkle_root": "833f67422a4a703a045304c72eec400a27b1d8ca5020073c94d7b6279ee9742e",
      "state_index_root": "1d43fee132a98a49c20ae6298bbea3f67943123a100ddbe666139de1c7cbdc5f",
      "timestamp": 1768312386,
      "miner_signature": "00e4931137cd50701994eba65922d41573ef70cf607a9f16112157bd3a65fdba525d719f46b4718b814c9493301c1c7316d3f015085f1db23c53434700c9379ca3",
      "signer_signature": [
        "0102df4f1414cc1de5f8ed88975dfbf70dbd2e185a93fcd575a524bdbf54e7aacc0db84a373884e89f4f9afed2e82e3ee49ad8ea430e9ff1fc8ef63d9ec9906190"
      ],
      "pox_treatment": "0f8a000001f2ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff03"
    }
  },
  "burn_view": "76aadfcfc5322c035ad7006e81810a43dbf52abf"
}

Signers

Get number of blocks signed by signer during a given reward cycle

GET

https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get number of blocks signed by signer during a given reward cycle

Parameters

signerstringrequiredpath

Hex-encoded compressed Secp256k1 public key of signer

cycle_numberintegerrequiredpath

Reward cycle number

Response

200OK

Number of blocks signed

Get number of blocks signed by signer during a given reward cycle

curl -X GET 'https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}'

const response = await fetch('https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}')
data = response.json()

const response = await fetch('https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://stacks.nownodes.io/v3/signer/{signer}/{cycle_number}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

200

Documentation

How to migrate to NOWNodes

Authentication

Stacks

Transactions

Authorizations

Body

Response

Authorizations

Parameters

Response

Smart Contracts

Authorizations

Parameters

Response

Authorizations

Body

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Body

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Accounts

Authorizations

Parameters

Response

Fees

Authorizations

Body

Response

Authorizations

Response

Info

Authorizations

Response

Authorizations

Parameters

Response

Mining

Authorizations

Body

Response

Authorizations

Parameters

Response

Blocks

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations