Blockbook API

v2.0.0-draft

Base URLs

https://qtum-blockbook.nownodes.io

https://qtum.nownodes.io

https://qtum-testnet.nownodes.io

Canonical description of the Blockbook public API, based on blockbook-api.ts, api/xpub.go, and the api/server handlers.

API V2 is the current Blockbook API. It is available over REST and over WebSocket using the WsRequest/WsResponse JSON envelope documented below. The normalized API shapes are shared by all supported coins, while blockchain-specific payloads remain extensible where Blockbook returns raw backend JSON.

Amounts are strings in the lowest denomination of the chain, such as satoshis or wei, without a decimal point. Empty fields are omitted: empty means null, an empty string, numeric zero, a null object, or an empty array. Since the same API serves many different chains, this can sometimes hide otherwise meaningful zero values such as transaction version 0.

Legacy API V1 is a Bitcore Insight-compatible subset for Bitcoin-type coins. It is provided as-is for compatibility and is not being extended.

Load estimates are qualitative hints for client authors. Low means a small constant-time lookup or cached metadata. Medium means bounded indexed work or response size. High means potentially large scans, large payloads, broadcast/backend work, or external RPC enrichment. Actual cost also depends on chain speed, backend health, cache warmth, mempool size, pageSize, gap, and the number of addresses, transactions, tokens, filters, or timestamps involved.

Authentication

api-keyAuthapiKey

API Key: api-key in header

MAINNET / Blockbook

BlockBook

Get Blockbook and backend status.

GET

https://qtum-blockbook.nownodes.io/api/status

Returns Blockbook sync state and connected backend metadata.

Load estimate: Low; constant-size status metadata.

Response

200OK

Current Blockbook and backend status.

default

Public API error. Public validation errors are HTTP 400; internal errors are HTTP 500.

Authorization

api-keyAuthapiKey in header

Get Blockbook and backend status.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/status'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/status', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/status')
data = response.json()

{
  "blockbook": {
    "coin": "Qtum",
    "network": "QTUM",
    "host": "04eb21242720",
    "version": "0.6.0",
    "gitCommit": "001cbd91-dirty",
    "buildTime": "2026-04-05T10:40:06+00:00",
    "syncMode": true,
    "initialSync": false,
    "inSync": true,
    "bestHeight": 5886881,
    "lastBlockTime": "2026-06-10T15:29:37.896986792Z",
    "inSyncMempool": true,
    "lastMempoolTime": "2026-06-10T15:29:37.895069631Z",
    "mempoolSize": 0,
    "decimals": 8,
    "dbSize": 23770921446,
    "hasFiatRates": true,
    "currentFiatRatesTime": "2026-06-10T15:30:01.444398818Z",
    "historicalFiatRatesTime": "2026-06-10T00:00:00Z",
    "about": "Blockbook - blockchain indexer for Trezor Suite https://trezor.io/trezor-suite. Do not use for any other purpose."
  },
  "backend": {
    "chain": "main",
    "blocks": 5886881,
    "headers": 5886881,
    "bestBlockHash": "87f618e5944e363061ef89b1490c479c4e2c0ee43ed44fc9fd27fef3a4859569",
    "difficulty": "1974284.532741494",
    "sizeOnDisk": 8241501703,
    "version": "290100",
    "subversion": "/Satoshi:29.1.0/",
    "protocolVersion": "70023",
    "timeOffset": -1
  }
}

{
  "error": "Transaction 'missing-txid' not found"
}

Get status from the API index handler.

GET

https://qtum-blockbook.nownodes.io/api

Alias served by the same handler as /api/status on full public interfaces.

Load estimate: Low; constant-size status metadata.

Response

200OK

Current Blockbook and backend status.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Get status from the API index handler.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/')
data = response.json()

{
  "blockbook": {
    "coin": "Qtum",
    "network": "QTUM",
    "host": "04eb21242720",
    "version": "0.6.0",
    "gitCommit": "001cbd91-dirty",
    "buildTime": "2026-04-05T10:40:06+00:00",
    "syncMode": true,
    "initialSync": false,
    "inSync": true,
    "bestHeight": 5886881,
    "lastBlockTime": "2026-06-10T15:29:37.896986792Z",
    "inSyncMempool": true,
    "lastMempoolTime": "2026-06-10T15:29:37.895069631Z",
    "mempoolSize": 0,
    "decimals": 8,
    "dbSize": 23770921446,
    "hasFiatRates": true,
    "currentFiatRatesTime": "2026-06-10T15:30:01.444398818Z",
    "historicalFiatRatesTime": "2026-06-10T00:00:00Z",
    "about": "Blockbook - blockchain indexer for Trezor Suite https://trezor.io/trezor-suite. Do not use for any other purpose."
  },
  "backend": {
    "chain": "main",
    "blocks": 5886881,
    "headers": 5886881,
    "bestBlockHash": "87f618e5944e363061ef89b1490c479c4e2c0ee43ed44fc9fd27fef3a4859569",
    "difficulty": "1974284.532741494",
    "sizeOnDisk": 8241501703,
    "version": "290100",
    "subversion": "/Satoshi:29.1.0/",
    "protocolVersion": "70023",
    "timeOffset": -1
  }
}

{
  "error": "Internal error"
}

Get a block hash by height.

GET

https://qtum-blockbook.nownodes.io/api/v2/block-index/{height}

Returns the block hash for a height on the backend main chain. Blockbook follows the backend main chain; after a rollback or reorg, height lookups resolve to the current main-chain block.

Load estimate: Low; indexed height-to-hash lookup.

Parameters

heightinteger>= 0requiredpath

Block height on the backend main chain.

Response

200OK

Block hash at the requested height.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Get a block hash by height.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v2/block-index/{height}'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v2/block-index/{height}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v2/block-index/{height}')
data = response.json()

{
  "blockHash": "0000000000000000000b7b8574bc6fd285825ec2dbcbeca149121fc05b0c828c"
}

{
  "error": "Block height out of range"
}

Get a block by height or hash.

GET

https://qtum-blockbook.nownodes.io/api/v2/block/{blockId}

Returns block information with paged transactions. When full transaction details are unavailable, the response can contain only transaction ids.

Blockbook follows the backend main chain. Height lookups always return the current main-chain block. Hash lookups can return a block from another fork only if the backend still keeps it.

Load estimate: Medium; grows mainly with block transaction count and requested page.

Parameters

blockIdstringrequiredpath

Block height or block hash.

pageinteger>= 1query

1-based page index. Values outside safe bounds are sanitized to the closest possible page.

Response

200OK

Block details.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Get a block by height or hash.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v2/block/{blockId}'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v2/block/{blockId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v2/block/{blockId}')
data = response.json()

{
  "page": 1,
  "totalPages": 1,
  "itemsOnPage": 1000,
  "hash": "760f8ed32894ccce9c1ea11c8a019cadaa82bcb434b25c30102dd7e43f326217",
  "previousBlockHash": "786a1f9f38493d32fd9f9c104d748490a070bc74a83809103bcadd93ae98288f",
  "nextBlockHash": "151615691b209de41dda4798a07e62db8429488554077552ccb1c4f8c7e9f57a",
  "height": 2648059,
  "confirmations": 47,
  "size": 951,
  "time": 1553096617,
  "version": "6422787",
  "merkleRoot": "6783f6083788c4f69b8af23bd2e4a194cf36ac34d590dfd97e510fe7aebc72c8",
  "nonce": "0",
  "bits": "1a063f3b",
  "difficulty": "2685605.260733312",
  "txCount": 2,
  "txs": [
    {
      "txid": "2b9fc57aaa8d01975631a703b0fc3f11d70671953fc769533b8078a04d029bf9",
      "vin": [
        {
          "n": 0,
          "isAddress": false,
          "value": "0"
        }
      ],
      "vout": [
        {
          "value": "1000100000000",
          "n": 0,
          "addresses": [
            "D6ravJL6Fgxtgp8k2XZZt1QfUmwwGuLwQJ"
          ],
          "isAddress": true
        }
      ],
      "blockHash": "760f8ed32894ccce9c1ea11c8a019cadaa82bcb434b25c30102dd7e43f326217",
      "blockHeight": 2648059,
      "confirmations": 47,
      "blockTime": 1553096617,
      "value": "1000100000000",
      "valueIn": "0",
      "fees": "0"
    }
  ]
}

{
  "error": "Block not found"
}

Get raw block hex.

GET

https://qtum-blockbook.nownodes.io/api/v2/rawblock/{blockId}

Returns raw serialized block data.

Load estimate: High for large blocks; payload size grows with the raw block size.

Parameters

blockIdstringrequiredpath

Block height or block hash.

Response

200OK

Raw block data.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Get raw block hex.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v2/rawblock/{blockId}'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v2/rawblock/{blockId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v2/rawblock/{blockId}')
data = response.json()

{
  "hex": "00000020f3e9..."
}

{
  "error": "Block not found"
}

Get compact block filters.

GET

https://qtum-blockbook.nownodes.io/api/v2/block-filters

Returns compact block filters for the script type configured on this Blockbook instance. Provide either lastN or a from/to range. When to is omitted for a range, the current best height is used.

Load estimate: High for wide ranges; work and payload grow linearly with the number of requested filters.

Parameters

scriptTypestringrequiredquery

Script type configured for block filters on this instance, for example taproot.

lastNinteger>= 1query

Return filters for the last N blocks.

frominteger>= 0query

First block height in the requested range.

tointeger>= 0query

Last block height in the requested range. Defaults to the current best height when omitted.

Response

200OK

Block filters keyed by block height.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Get compact block filters.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v2/block-filters/'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v2/block-filters/', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v2/block-filters/')
data = response.json()

{
  "P": 19,
  "M": 784931,
  "zeroedKey": false,
  "blockFilters": {
    "860730": {
      "blockHash": "00000000000000000000effeb0c4460480e6a347deab95332c63007a68646ee5",
      "filter": "0286f0..."
    }
  }
}

{
  "error": "Invalid scriptType"
}

Get a normalized transaction.

GET

https://qtum-blockbook.nownodes.io/api/v2/tx/{txid}

Returns normalized transaction data with the same general structure for all supported coins. Coin-specific fields that do not fit the common shape are omitted here; use getTransactionSpecific for backend-native JSON.

Bitcoin-like confirmed transactions include blockHash, confirmations, blockTime, size/vsize, value/valueIn, fees, and hex. Unconfirmed transactions can include confirmationETABlocks and confirmationETASeconds.

Ethereum-like transactions have one vin and one vout, tokenTransfers, ethereumSpecific execution data, and optional addressAliases. Parsed input data is included when the 4byte signature can be resolved.

For mined transactions, blockTime is the block timestamp. For mempool transactions, blockTime is when this Blockbook instance first learned about the transaction and can differ between instances.

Load estimate: Medium; grows with inputs, outputs, token transfers, address aliases, and spending=true extra lookups.

Parameters

txidstringrequiredpath

Transaction id/hash.

spendingbooleanquery

Include spending transaction metadata for UTXO outputs when available.

Response

200OK

Normalized transaction.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Get a normalized transaction.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v2/tx/{txid}'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v2/tx/{txid}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v2/tx/{txid}')
data = response.json()

{
  "txid": "8c1e3dec662d1f2a5e322ccef5eca263f98eb16723c6f990be0c88c1db113fb1",
  "version": 2,
  "lockTime": 860729,
  "vin": [
    {
      "txid": "0eb7b574373de2c88d0dc1444f49947c681d0437d21361f9ebb4dd09c62f2a66",
      "vout": 1,
      "sequence": 4294967293,
      "n": 0,
      "addresses": [
        "bc1qmgwnfjlda4ns3g6g3yz74w6scnn9yu2ts82yyc"
      ],
      "isAddress": true,
      "value": "10106300"
    }
  ],
  "vout": [
    {
      "value": "175000",
      "n": 0,
      "hex": "76a914ecc999d554eaa3efa5e871c28f58b549c36ec51788ac",
      "addresses": [
        "1Nb1ykSD7J5k4RFjJQGsrD9gxBE6jzfNa9"
      ],
      "isAddress": true
    },
    {
      "value": "9888100",
      "n": 1,
      "hex": "001496f152a0919487624bf4f13f46f0d20fa10d9acc",
      "addresses": [
        "bc1qjmc49gy3jjrkyjl57yl5duxjp7ssmxkvh5t2q5"
      ],
      "isAddress": true
    }
  ],
  "blockHash": "00000000000000000000effeb0c4460480e6a347deab95332c63007a68646ee5",
  "blockHeight": 860730,
  "confirmations": 1,
  "blockTime": 1725956288,
  "size": 225,
  "vsize": 144,
  "value": "10063100",
  "valueIn": "10106300",
  "fees": "43200",
  "hex": "02000000000101662a..."
}

{
  "txid": "73b1ad97194e426031e5c692869de2d83dc2ff6033fc6f0ab5514345f92eaf0d",
  "version": 2,
  "vin": [
    {
      "txid": "bccbebb64b1613ada74eefa96753088a80fefa53a10e42c66eef1899371bc096",
      "n": 0,
      "addresses": [
        "bc1q9lh77es6m8ztr7muwcec00ewn8fxakpl9jwv8y"
      ],
      "isAddress": true,
      "value": "371042"
    }
  ],
  "vout": [
    {
      "value": "293135",
      "n": 0,
      "hex": "0014aafd7386f99f4b508ec05ee8f7edc2e07126620a",
      "addresses": [
        "bc1q4t7h8phena94prkqtm500mwzupcjvcs2akcdy9"
      ],
      "isAddress": true
    }
  ],
  "blockHeight": -1,
  "confirmations": 0,
  "confirmationETABlocks": 1,
  "confirmationETASeconds": 619,
  "blockTime": 1725959035,
  "size": 222,
  "vsize": 141,
  "value": "367157",
  "valueIn": "371042",
  "fees": "3885",
  "rbf": true
}

{
  "txid": "0xa6c8ae1f91918d09cf2bd67bbac4c168849e672fd81316fa1d26bb9b4fc0f790",
  "vin": [
    {
      "n": 0,
      "addresses": [
        "0xd446089cf19C3D3Eb1743BeF3A852293Fd2C7775"
      ],
      "isAddress": true
    }
  ],
  "vout": [
    {
      "value": "5615959129349132871",
      "n": 0,
      "addresses": [
        "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
      ],
      "isAddress": true
    }
  ],
  "blockHash": "0x10ea8cfecda89d6d864c1d919911f819c9febc2b455b48c9918cee3c6cdc4adb",
  "blockHeight": 16529834,
  "confirmations": 3,
  "blockTime": 1675204631,
  "value": "5615959129349132871",
  "fees": "19141662404282012",
  "tokenTransfers": [
    {
      "type": "ERC20",
      "standard": "ERC20",
      "from": "0xd446089cf19C3D3Eb1743BeF3A852293Fd2C7775",
      "to": "0x3B685307C8611AFb2A9E83EBc8743dc20480716E",
      "contract": "0x4E15361FD6b4BB609Fa63C81A2be19d873717870",
      "name": "Fantom Token",
      "symbol": "FTM",
      "decimals": 18,
      "value": "15362368338194882707417"
    }
  ],
  "ethereumSpecific": {
    "status": 1,
    "nonce": 505,
    "gasLimit": 550941,
    "gasUsed": 434686,
    "gasPrice": "44035608242",
    "maxPriorityFeePerGas": "44035608243",
    "maxFeePerGas": "44035608244",
    "baseFeePerGas": "2035608244",
    "data": "0xac9650d800000000000000000000",
    "parsedData": {
      "methodId": "0xfa2b068f",
      "name": "Mint",
      "function": "mint(address, uint256, uint32, bytes32[], address)",
      "params": [
        {
          "type": "address",
          "values": [
            "0xa5fD1Da088598e88ba731B0E29AECF0BC2A31F82"
          ]
        }
      ]
    },
    "internalTransfers": [
      {
        "type": 0,
        "from": "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
        "to": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
        "value": "5615959129349132871"
      }
    ]
  },
  "addressAliases": {
    "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": {
      "Type": "Contract",
      "Alias": "Wrapped Ether"
    }
  }
}

{
  "error": "Transaction not found"
}

Get blockchain-specific transaction JSON.

GET

https://qtum-blockbook.nownodes.io/api/v2/tx-specific/{txid}

Returns transaction data in the exact backend-specific format. Use this when a chain exposes fields that are intentionally absent from the normalized Tx schema.

Load estimate: Medium; payload size depends on chain-specific fields and transaction complexity.

Parameters

txidstringrequiredpath

Transaction id/hash.

Response

200OK

Chain-specific transaction payload.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Get blockchain-specific transaction JSON.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v2/tx-specific/{txid}'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v2/tx-specific/{txid}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v2/tx-specific/{txid}')
data = response.json()

{
  "hex": "040000808...8e6e73cb009",
  "txid": "7a0a0ff6f67bac2a856c7296382b69151949878de6fb0d01a8efa197182b2913",
  "size": 1809,
  "overwintered": true,
  "version": 4,
  "versiongroupid": "892f2085",
  "locktime": 0,
  "expiryheight": 495680,
  "vin": [],
  "vout": [],
  "blockhash": "0000000001c4aa394e796dd1b82e358f114535204f6f5b6cf4ad58dc439c47af",
  "height": 495665,
  "confirmations": 2145803,
  "time": 1552301566,
  "blocktime": 1552301566
}

{
  "error": "Transaction not found"
}

Get raw transaction hex.

GET

https://qtum-blockbook.nownodes.io/api/rawtx/{txid}

Unversioned public endpoint exposed by Blockbook for raw transaction data.

Load estimate: Medium; payload size grows with raw transaction size.

Parameters

txidstringrequiredpath

Transaction id/hash.

Response

200OK

Raw transaction hex as a JSON string.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Get raw transaction hex.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/rawtx/{txid}'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/rawtx/{txid}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/rawtx/{txid}')
data = response.json()

"02000000000101662a2fc609ddb4eb..."

{
  "error": "Transaction not found"
}

Broadcast a raw transaction using the path.

GET

https://qtum-blockbook.nownodes.io/api/v2/sendtx/{hex}

Broadcasts hex-encoded raw transaction data. Prefer POST for large payloads.

Load estimate: High; validates and forwards to the backend, with cost growing with transaction size and backend mempool policy checks.

Parameters

hexstringrequiredpath

Raw transaction.

Response

200OK

Broadcast result.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Broadcast a raw transaction using the path.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v2/sendtx/{hex}'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v2/sendtx/{hex}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v2/sendtx/{hex}')
data = response.json()

{
  "result": "7c3be24063f268aaa1ed81b64776798f56088757641a34fb156c4f51ed2e9d25"
}

{
  "error": "Invalid transaction hex"
}

Broadcast a raw transaction using the request body.

POST

https://qtum-blockbook.nownodes.io/api/v2/sendtx

Broadcasts hex-encoded raw transaction data from the request body. The trailing slash is mandatory in the Blockbook handler. POST bodies are limited to 8 MiB.

Load estimate: High; validates and forwards to the backend, with cost growing with transaction size and backend mempool policy checks.

Body

text/plain

string

Response

200OK

Broadcast result.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Broadcast a raw transaction using the request body.

curl -X POST 'https://qtum-blockbook.nownodes.io/api/v2/sendtx/' \
  -H 'Content-Type: text/plain' \
  -d '"02000000000101662a..."'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v2/sendtx/', {
  method: 'POST',
  headers: {
    'Content-Type': 'text/plain',
  },
  body: JSON.stringify("02000000000101662a..."),
});

const data = await response.json();

import requests

payload = "02000000000101662a..."

response = requests.post('https://qtum-blockbook.nownodes.io/api/v2/sendtx/', json=payload)
data = response.json()

Request Body

02000000000101662a...

{
  "result": "7c3be24063f268aaa1ed81b64776798f56088757641a34fb156c4f51ed2e9d25"
}

{
  "error": "Invalid transaction hex"
}

Get address/account details.

GET

https://qtum-blockbook.nownodes.io/api/v2/address/{address}

Returns balances and transactions of an address. Transactions are sorted by block height with newest blocks first. Response size is controlled by the details parameter.

At details=basic, mempool transactions are not aggregated: unconfirmedBalance, unconfirmedSending, and unconfirmedReceiving are omitted, and unconfirmedTxs reports the raw mempool index size for the address.

Load estimate: Variable; basic is low, token/tokenBalances and txids/txslight are medium, and txs can be high as it grows with pageSize, transactions, token rows, filters, and protocol enrichment.

Parameters

addressstringrequiredpath

Chain address.

pageinteger>= 1query

1-based page index. Values outside safe bounds are sanitized to the closest possible page.

pageSizeinteger[1, 1000]query

Number of history items per page. The default and maximum for REST account endpoints is 1000.

frominteger>= 0query

First block height included in account transaction filtering.

tointeger>= 0query

Last block height included in account transaction filtering.

detailsstringbasictokenstokenBalancestxidstxslighttxstxidsquery

Controls how much account data is returned. basic returns balances and counts only. tokens adds known token rows. tokenBalances returns token rows with balances. txids adds paged transaction ids. txslight adds limited transaction details from the index. txs adds full transaction details.

filterstring | integerquery

Filter account history by input/output side, or by numeric token/internal filter id.

contractstringquery

Contract address used to filter token data.

protocolsArray<string>query

Optional protocol enrichments, comma-separated or repeated. Currently supported value: erc4626. Unknown values are rejected.

secondarystringquery

Secondary currency code used to populate fiat values.

Response

200OK

Address/account details.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Get address/account details.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v2/address/{address}'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v2/address/{address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v2/address/{address}')
data = response.json()

{
  "page": 1,
  "totalPages": 1,
  "itemsOnPage": 1000,
  "address": "bc1q0wd209cv5k9pd9mhk7nspacywcj038xxdhnt5u",
  "balance": "4225100",
  "totalReceived": "4225100",
  "totalSent": "0",
  "unconfirmedBalance": "0",
  "unconfirmedTxs": 0,
  "txs": 2,
  "txids": [
    "0db6010dc0815a4bdaa505bd1ccc851056b0d53c7e4ea7af39c4d648a2c0c019",
    "7532920ddc506218337cceac978cce9c7f98e27ad3226dee55f3e934e0b32e80"
  ]
}

{
  "address": "0x2df3951b2037bA620C20Ed0B73CCF45Ea473e83B",
  "balance": "21004631949601199",
  "unconfirmedBalance": "0",
  "unconfirmedTxs": 0,
  "txs": 5,
  "nonTokenTxs": 3,
  "nonce": "1",
  "tokens": [
    {
      "type": "ERC20",
      "standard": "ERC20",
      "name": "Tether USD",
      "contract": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
      "transfers": 3,
      "symbol": "USDT",
      "decimals": 6,
      "balance": "4913000000",
      "baseValue": 3.104622978658881,
      "secondaryValue": 4914.214559070491
    }
  ],
  "secondaryValue": 33.247601671503574,
  "tokensBaseValue": 3.104622978658881,
  "tokensSecondaryValue": 4914.214559070491,
  "totalBaseValue": 3.125627610608482,
  "totalSecondaryValue": 4947.462160741995
}

{
  "error": "Address not found"
}

Get account balance history.

GET

https://qtum-blockbook.nownodes.io/api/v2/balancehistory/{descriptor}

Returns balance history points for an address, XPUB, or descriptor. from and to are Unix timestamps. groupBy is an aggregation interval in seconds and defaults to 3600. When fiatcurrency is omitted, rates can contain all available currencies. sentToSelf is the amount sent from an address to itself or within addresses of the same XPUB.

Load estimate: High; grows with account transaction history, time span, grouping cardinality, fiat rate lookups, and XPUB/descriptor gap.

Parameters

descriptorstringrequiredpath

Address, XPUB, or supported descriptor. URL-encode descriptors.

frominteger<int64>query

Unix timestamp lower bound.

tointeger<int64>query

Unix timestamp upper bound.

fiatcurrencystringquery

Optional fiat currency code to include in rates.

groupByinteger>= 1query

Aggregation interval in seconds. Defaults to 3600.

gapinteger[0, 10000]query

XPUB/address derivation gap limit.

Response

200OK

Balance history points.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Get account balance history.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v2/balancehistory/{descriptor}'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v2/balancehistory/{descriptor}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v2/balancehistory/{descriptor}')
data = response.json()

[
  {
    "time": 1578391200,
    "txs": 5,
    "received": "5000000",
    "sent": "0",
    "sentToSelf": "100000",
    "rates": {
      "usd": 7855.9,
      "eur": 6838.13
    }
  },
  {
    "time": 1578488400,
    "txs": 1,
    "received": "0",
    "sent": "5000000",
    "sentToSelf": "0",
    "rates": {
      "usd": 8283.11,
      "eur": 7464.45
    }
  }
]

[
  {
    "time": 1578391200,
    "txs": 5,
    "received": "5000000",
    "sent": "0",
    "sentToSelf": "0",
    "rates": {
      "usd": 7855.9
    }
  },
  {
    "time": 1578488400,
    "txs": 1,
    "received": "0",
    "sent": "5000000",
    "sentToSelf": "0",
    "rates": {
      "usd": 8283.11
    }
  }
]

[
  {
    "time": 1578355200,
    "txs": 6,
    "received": "5000000",
    "sent": "5000000",
    "sentToSelf": "0",
    "rates": {
      "usd": 7734.45
    }
  }
]

{
  "error": "Invalid descriptor"
}

Get contract metadata.

GET

https://qtum-blockbook.nownodes.io/api/v2/contract/{contract}

Returns indexed token/contract metadata and optional current protocol enrichments such as ERC4626.

blockHeight reflects the indexer's best block at request time. ERC4626 fields under protocols.erc4626 are fetched through JSON-RPC calls pinned to that exact blockHeight, so the ERC4626 values are a consistent snapshot. If a vault is detected but the underlying asset metadata cannot be resolved, protocols.erc4626 contains error and omits asset; callers must not derive fiat rates or human-unit exchange rates from such a partial response.

Load estimate: Medium; indexed metadata is cheap, but optional protocol enrichment can add backend RPC calls and token metadata lookups.

Parameters

contractstringrequiredpath

Smart contract address.

currencystringquery

Secondary currency code for rates.

protocolsArray<string>query

Optional protocol enrichments, comma-separated or repeated.

Response

200OK

Contract metadata.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Get contract metadata.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v2/contract/{contract}'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v2/contract/{contract}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v2/contract/{contract}')
data = response.json()

{
  "type": "ERC20",
  "standard": "ERC20",
  "contract": "0x0000000000000000000000000000000000000001",
  "name": "Vault Share",
  "symbol": "vETH",
  "decimals": 18,
  "rates": {
    "baseRate": 0.000523,
    "currency": "usd",
    "secondaryRate": 1.24
  },
  "protocols": {
    "erc4626": {
      "asset": {
        "contract": "0x0000000000000000000000000000000000000002",
        "name": "Wrapped Ether",
        "symbol": "WETH",
        "decimals": 18
      },
      "share": {
        "contract": "0x0000000000000000000000000000000000000001",
        "name": "Vault Share",
        "symbol": "vETH",
        "decimals": 18
      },
      "totalAssets": "123456789",
      "convertToAssets1Share": "1000000000000000000",
      "convertToShares1Asset": "1000000000000000000",
      "previewDeposit1Asset": "999999999999999999",
      "previewRedeem1Share": "1000000000000000000"
    }
  },
  "blockHeight": 12345678
}

{
  "error": "Contract not found"
}

Estimate a fee target.

GET

https://qtum-blockbook.nownodes.io/api/v2/estimatefee/{blocks}

Returns backend fee estimation for the requested confirmation target.

Load estimate: Low; a small backend fee estimate lookup.

Parameters

blocksinteger>= 1requiredpath

Confirmation target in blocks.

conservativebooleantruequery

Use conservative smart fee estimation where supported.

Response

200OK

Decimal fee estimate in chain base currency.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Estimate a fee target.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v2/estimatefee/{blocks}'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v2/estimatefee/{blocks}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v2/estimatefee/{blocks}')
data = response.json()

{
  "result": "0.00002460"
}

{
  "error": "Fee estimation not available"
}

Get fee statistics for a block.

GET

https://qtum-blockbook.nownodes.io/api/v2/feestats/{blockId}

Returns fee statistics for transactions in one block.

Load estimate: Medium to high; grows with the number of transactions in the requested block.

Parameters

blockIdstringrequiredpath

Block height or block hash.

Response

200OK

Fee statistics.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Get fee statistics for a block.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v2/feestats/{blockId}'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v2/feestats/{blockId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v2/feestats/{blockId}')
data = response.json()

{
  "txCount": 1820,
  "totalFeesSat": "182000000",
  "averageFeePerKb": 23.41,
  "decilesFeePerKb": [
    3.1,
    5.4,
    8.8,
    11.2,
    15.7,
    20.3,
    26.8,
    35.1,
    48.4,
    91.6
  ]
}

{
  "error": "Block not found"
}

Get current or historical fiat rates.

GET

https://qtum-blockbook.nownodes.io/api/v2/tickers

Returns currency rates for the requested currency and date. If a rate is unavailable for the exact timestamp, the closest available rate can be returned. Responses include the actual rate timestamp. Without a currency parameter, all available currencies can be returned. A rate of -1 marks an unavailable or invalid currency for that timestamp.

Load estimate: Low to medium; specific currency lookups are cheap, while omitted currency and token lookups increase response size.

Parameters

currencystringquery

Optional currency code. When omitted, all available rates can be returned.

timestampinteger<int64>query

Unix timestamp for historical rates.

blockstringquery

Block height or hash whose timestamp should be used for historical rates.

tokenstringquery

Optional token symbol or contract/address key for token-specific rates.

Response

200OK

Fiat rate ticker.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Get current or historical fiat rates.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v2/tickers/'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v2/tickers/', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v2/tickers/')
data = response.json()

{
  "ts": 1574346615,
  "rates": {
    "eur": 7134.1,
    "usd": 7914.5
  }
}

{
  "ts": 1574346615,
  "rates": {
    "usd": 7914.5
  }
}

{
  "ts": 7980386400,
  "rates": {
    "usd": -1
  }
}

{
  "error": "Invalid currency"
}

Get fiat rates for multiple timestamps.

GET

https://qtum-blockbook.nownodes.io/api/v2/multi-tickers

Returns fiat rate tickers for a comma-separated list of Unix timestamps.

Load estimate: Medium; work and payload grow linearly with timestamp count, plus token/currency selection.

Parameters

timestampstringrequiredquery

Comma-separated Unix timestamps.

currencystringquery

Optional currency code.

tokenstringquery

Optional token symbol or contract/address key.

Response

200OK

Fiat rate tickers.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Get fiat rates for multiple timestamps.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v2/multi-tickers/'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v2/multi-tickers/', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v2/multi-tickers/')
data = response.json()

[
  {
    "ts": 1574346615,
    "rates": {
      "usd": 7914.5
    }
  },
  {
    "ts": 1574433015,
    "rates": {
      "usd": 7344.2
    }
  }
]

{
  "error": "Invalid timestamp"
}

Get currencies available for a timestamp.

GET

https://qtum-blockbook.nownodes.io/api/v2/tickers-list

Returns available secondary currencies for a date together with the actual rate timestamp.

Load estimate: Low to medium; token lookups and wide currency lists increase response size.

Parameters

timestampinteger<int64>requiredquery

Unix timestamp for the requested currency list.

tokenstringquery

Optional token symbol or contract/address key.

Response

200OK

Available currencies.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Get currencies available for a timestamp.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v2/tickers-list/'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v2/tickers-list/', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v2/tickers-list/')
data = response.json()

{
  "ts": 1574346615,
  "available_currencies": [
    "eur",
    "usd"
  ]
}

{
  "error": "Invalid timestamp"
}

BlockBook (legacy)

Legacy get block hash by height.

GET

https://qtum-blockbook.nownodes.io/api/v1/block-index/{height}

Bitcore Insight-compatible V1 route for Bitcoin-type coins.

Load estimate: Low; indexed height-to-hash lookup.

Parameters

heightinteger>= 0requiredpath

Block height on the backend main chain.

Response

200OK

Block hash at the requested height.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Legacy get block hash by height.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v1/block-index/{height}'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v1/block-index/{height}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v1/block-index/{height}')
data = response.json()

{
  "blockHash": "0000000000000000000b7b8574bc6fd285825ec2dbcbeca149121fc05b0c828c"
}

{
  "error": "Block not found"
}

Legacy get transaction.

GET

https://qtum-blockbook.nownodes.io/api/v1/tx/{txid}

Bitcore Insight-compatible V1 transaction shape for Bitcoin-type coins.

Load estimate: Medium; grows with inputs, outputs, scripts, and raw transaction size.

Parameters

txidstringrequiredpath

Transaction id/hash.

Response

200OK

Legacy transaction payload.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Legacy get transaction.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v1/tx/{txid}'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v1/tx/{txid}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v1/tx/{txid}')
data = response.json()

{}

{
  "error": "Transaction not found"
}

Legacy get address.

GET

https://qtum-blockbook.nownodes.io/api/v1/address/{address}

Bitcore Insight-compatible V1 address shape for Bitcoin-type coins.

Load estimate: Variable; grows with address transaction count and legacy response expansion.

Parameters

addressstringrequiredpath

Chain address.

Response

200OK

Legacy address payload.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Legacy get address.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v1/address/{address}'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v1/address/{address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v1/address/{address}')
data = response.json()

{}

{
  "error": "Address not found"
}

Legacy get address UTXOs.

GET

https://qtum-blockbook.nownodes.io/api/v1/utxo/{address}

Bitcore Insight-compatible V1 UTXO list for Bitcoin-type coins.

Load estimate: Medium; grows with the number of unspent outputs.

Parameters

addressstringrequiredpath

Chain address.

Response

200OK

Legacy UTXO list.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Legacy get address UTXOs.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v1/utxo/{address}'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v1/utxo/{address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v1/utxo/{address}')
data = response.json()

[
  {}
]

{
  "error": "Address not found"
}

Legacy get block by height or hash.

GET

https://qtum-blockbook.nownodes.io/api/v1/block/{blockId}

Bitcore Insight-compatible V1 block shape for Bitcoin-type coins.

Load estimate: Medium to high; grows with block transaction count and legacy payload size.

Parameters

blockIdstringrequiredpath

Block height or block hash.

Response

200OK

Legacy block payload.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Legacy get block by height or hash.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v1/block/{blockId}'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v1/block/{blockId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v1/block/{blockId}')
data = response.json()

{}

{
  "error": "Block not found"
}

Legacy estimate fee target.

GET

https://qtum-blockbook.nownodes.io/api/v1/estimatefee/{blocks}

Bitcore Insight-compatible V1 fee estimate for Bitcoin-type coins.

Load estimate: Low; a small backend fee estimate lookup.

Parameters

blocksinteger>= 1requiredpath

Confirmation target in blocks.

Response

200OK

Decimal fee estimate in chain base currency.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Legacy estimate fee target.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v1/estimatefee/{blocks}'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v1/estimatefee/{blocks}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v1/estimatefee/{blocks}')
data = response.json()

{
  "result": "0.00002460"
}

{
  "error": "Fee estimation not available"
}

Legacy broadcast transaction using the path.

GET

https://qtum-blockbook.nownodes.io/api/v1/sendtx/{hex}

Bitcore Insight-compatible V1 broadcast route for Bitcoin-type coins.

Load estimate: High; validates and forwards to the backend, with cost growing with transaction size and backend mempool policy checks.

Parameters

hexstringrequiredpath

Raw transaction.

Response

200OK

Broadcast result.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Legacy broadcast transaction using the path.

curl -X GET 'https://qtum-blockbook.nownodes.io/api/v1/sendtx/{hex}'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v1/sendtx/{hex}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://qtum-blockbook.nownodes.io/api/v1/sendtx/{hex}')
data = response.json()

{
  "result": "7c3be24063f268aaa1ed81b64776798f56088757641a34fb156c4f51ed2e9d25"
}

{
  "error": "Invalid transaction hex"
}

Legacy broadcast transaction using the request body.

POST

https://qtum-blockbook.nownodes.io/api/v1/sendtx

Bitcore Insight-compatible V1 broadcast route for Bitcoin-type coins.

Load estimate: High; validates and forwards to the backend, with cost growing with transaction size and backend mempool policy checks.

Body

text/plain

string

Response

200OK

Broadcast result.

default

Public API error.

Authorization

api-keyAuthapiKey in header

Legacy broadcast transaction using the request body.

curl -X POST 'https://qtum-blockbook.nownodes.io/api/v1/sendtx/' \
  -H 'Content-Type: text/plain' \
  -d '"02000000000101662a..."'

const response = await fetch('https://qtum-blockbook.nownodes.io/api/v1/sendtx/', {
  method: 'POST',
  headers: {
    'Content-Type': 'text/plain',
  },
  body: JSON.stringify("02000000000101662a..."),
});

const data = await response.json();

import requests

payload = "02000000000101662a..."

response = requests.post('https://qtum-blockbook.nownodes.io/api/v1/sendtx/', json=payload)
data = response.json()

Request Body

02000000000101662a...

{
  "result": "7c3be24063f268aaa1ed81b64776798f56088757641a34fb156c4f51ed2e9d25"
}

{
  "error": "Invalid transaction hex"
}

MAINNET / Blockchain_RPCs

getbestblockhash

POST

https://qtum-blockbook.nownodes.io/

Returns the hash of the best block in the most-work fully-validated chain. The best block is the tip of the blockchain, representing the most recent block that has been validated and added to the chain.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetbestblockhashrequired

paramsArray<any>required

Response

200OK

Valid response

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getbestblockhash

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getbestblockhash",
    "params": []
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getbestblockhash",
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getbestblockhash",
  "params": []
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getbestblockhash",
  "params": []
}

{
  "result": "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getblock

POST

https://qtum-blockbook.nownodes.io/

Returns information about the block with the given block hash. Optional verbosity levels determine the level of detail in the response:

0: Returns a string that is serialized, hex-encoded data for the block.
1: Returns a JSON object with basic block details and txids.
2: Returns a JSON object with detailed transaction info.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetblockrequired

paramsArray<string | integer>required

Parameters:

blockhash (string) – The hash of the block
verbosity (integer, optional) – Level of detail: 0, 1, or 2

Show child attributes

One of

string

integer

Response

200OK

Block information retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getblock

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getblock",
    "params": [
      "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
      1
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getblock",
      "params": [
        "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
        1
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblock",
  "params": [
    "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
    1
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblock",
  "params": [
    "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
    1
  ]
}

{
  "result": {
    "hash": "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
    "confirmations": 100,
    "height": 855000,
    "version": 536870912,
    "versionHex": "20000000",
    "merkleroot": "a3e1f3...ff9a",
    "time": 1700000000,
    "mediantime": 1699995000,
    "nonce": 4282073135,
    "bits": "170d1f5d",
    "difficulty": 225983213292.9388,
    "chainwork": "0000000000000000000000000000000000000000230c36f8ff7f4fbee5b6a0c2",
    "previousblockhash": "0000000000000000000c1e1ecf0aef02b1c3d4c44c920afe0aaec7d08d0019e1",
    "nextblockhash": "0000000000000000000735c64b80cd102b8e4d67c2cc09db81fa4451a6f58e3a",
    "tx": [
      "string"
    ]
  },
  "error": {},
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getblockchaininfo

POST

https://qtum-blockbook.nownodes.io/

Returns an object containing various state info regarding blockchain processing.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetblockchaininforequired

paramsArray<any>required

Response

200OK

Blockchain state information retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getblockchaininfo

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getblockchaininfo",
    "params": []
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getblockchaininfo",
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblockchaininfo",
  "params": []
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblockchaininfo",
  "params": []
}

{
  "result": {
    "chain": "main",
    "blocks": 855000,
    "headers": 855002,
    "bestblockhash": "0000000000000000000b27d455de872dfe8a8aa4f2efbfc5f1877357f7c8e97b",
    "difficulty": 225983213292.9388,
    "mediantime": 1700000500,
    "verificationprogress": 0.999999,
    "initialblockdownload": false,
    "chainwork": "0000000000000000000000000000000000000000230c36f8ff7f4fbee5b6a0c2",
    "size_on_disk": 495000000000,
    "pruned": false,
    "pruneheight": null,
    "automatic_pruning": false,
    "prune_target_size": null,
    "warnings": ""
  },
  "error": {},
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getblockcount

POST

https://qtum-blockbook.nownodes.io/

Returns the number of blocks in the longest blockchain. This number increases as new blocks are added.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetblockcountrequired

paramsarrayrequired

This method takes no parameters.

Response

200OK

Current block height retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getblockcount

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getblockcount",
    "params": []
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getblockcount",
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblockcount",
  "params": []
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblockcount",
  "params": []
}

{
  "result": 855000,
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getblockhash

POST

https://qtum-blockbook.nownodes.io/

Returns the block hash of the block at the given height in the blockchain. You must provide a block height (0-based index).

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetblockhashrequired

paramsArray<integer>required

Parameters:

height (integer) — The height (index) of the block.

Response

200OK

Block hash successfully retrieved

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getblockhash

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getblockhash",
    "params": [
      855000
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getblockhash",
      "params": [
        855000
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblockhash",
  "params": [
    855000
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblockhash",
  "params": [
    855000
  ]
}

{
  "result": "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getblockheader

POST

https://qtum-blockbook.nownodes.io/

Returns information about the block header given a block hash. You can specify whether to return a JSON object or raw hex-encoded string using the verbose flag.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetblockheaderrequired

paramsArray<string | boolean>required

Parameters:

blockhash (string) — The hash of the block.
verbose (boolean, optional) — If true, returns a JSON object; if false, returns a hex string. Default is true.

Show child attributes

One of

string

boolean

Response

200OK

Block header information retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getblockheader

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getblockheader",
    "params": [
      "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
      true
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getblockheader",
      "params": [
        "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
        true
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblockheader",
  "params": [
    "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
    true
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblockheader",
  "params": [
    "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
    true
  ]
}

{
  "result": {
    "hash": "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
    "confirmations": 105,
    "height": 855000,
    "version": 536870912,
    "versionHex": "20000000",
    "merkleroot": "e3abc1234...",
    "time": 1700000000,
    "mediantime": 1699995000,
    "nonce": 1234567890,
    "bits": "170d1f5d",
    "difficulty": 225983213292.9388,
    "chainwork": "0000000000000000000000000000000000000000230c36f8ff7f4fbee5b6a0c2",
    "previousblockhash": "0000000000000000000c1e1ecf0aef02b1c3d4c44c920afe0aaec7d08d0019e1",
    "nextblockhash": "0000000000000000000735c64b80cd102b8e4d67c2cc09db81fa4451a6f58e3a"
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getblockstats

POST

https://qtum-blockbook.nownodes.io/

Returns a variety of statistics about the block identified by its height or block hash.

Body

application/json

jsonrpcstring1.02.0required

JSON-RPC protocol version.

methodstringgetblockstatsrequired

Name of the RPC method.

paramsArray<integer>

Parameters for the method. For getblockstats, this is an array containing a single value – either the block height (integer) or block hash (string).

idstringrequired

Request identifier. The response will echo this value. Can be any string or number.

Response

200OK

Successful block statistics retrieval.

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getblockstats

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "method": "getblockstats",
    "params": [
      855000
    ],
    "id": "curltest"
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "method": "getblockstats",
      "params": [
        855000
      ],
      "id": "curltest"
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "method": "getblockstats",
  "params": [
    855000
  ],
  "id": "curltest"
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblockstats",
  "params": [
    855000
  ]
}

{
  "result": {
    "avgfee": 2506,
    "avgfeerate": 5,
    "avgtxsize": 758,
    "blockhash": "0000000000000000000233ea80aa10d38aa4486cd7033fffc2c4df556d0b9138",
    "feerate_percentiles": [
      3,
      3,
      4,
      5,
      7
    ],
    "height": 855000,
    "ins": 9241,
    "maxfee": 315273,
    "maxfeerate": 974,
    "maxtxsize": 208603,
    "medianfee": 717,
    "mediantime": 1722542196,
    "mediantxsize": 223,
    "minfee": 143,
    "minfeerate": 1,
    "mintxsize": 150,
    "outs": 7778,
    "subsidy": 312500000,
    "swtotal_size": 1662368,
    "swtotal_weight": 3546428,
    "swtxs": 2189,
    "time": 1722544444,
    "total_out": 784184758176,
    "total_size": 1773719,
    "total_weight": 3991832,
    "totalfee": 5858578,
    "txs": 2338,
    "utxo_increase": -1463,
    "utxo_size_inc": -107691,
    "utxo_increase_actual": -2000,
    "utxo_size_inc_actual": -139944
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getchaintips

POST

https://qtum-blockbook.nownodes.io/

Returns information about all known tips in the block tree, including the main chain as well as orphaned forks.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetchaintipsrequired

paramsarrayrequired

This method takes no parameters.

Response

200OK

Chain tips retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getchaintips

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getchaintips",
    "params": []
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getchaintips",
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getchaintips",
  "params": []
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getchaintips",
  "params": []
}

{
  "result": [
    {
      "height": 855000,
      "hash": "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
      "branchlen": 0,
      "status": "active"
    },
    {
      "height": 854980,
      "hash": "0000000000000000000f83a8e9a563e48e7b8e5400e38310ff299b7f30aaf8d9",
      "branchlen": 20,
      "status": "valid-fork"
    }
  ],
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getchaintxstats

POST

https://qtum-blockbook.nownodes.io/

Compute statistics about the total number and rate of transactions in the blockchain. You can optionally specify the number of blocks and a block hash to start from.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetchaintxstatsrequired

paramsArray<integer | string>required

Parameters:

nblocks (integer, optional) — Number of blocks to average over. Default: 1 month worth (~4320).
blockhash (string, optional) — Hash of the block to stop at; defaults to the chain tip.

Show child attributes

One of

integer

string

Response

200OK

Chain transaction statistics retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getchaintxstats

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getchaintxstats",
    "params": [
      144,
      "0000000000000000000c1e1ecf0aef02b1c3d4c44c920afe0aaec7d08d0019e1"
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getchaintxstats",
      "params": [
        144,
        "0000000000000000000c1e1ecf0aef02b1c3d4c44c920afe0aaec7d08d0019e1"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getchaintxstats",
  "params": [
    144,
    "0000000000000000000c1e1ecf0aef02b1c3d4c44c920afe0aaec7d08d0019e1"
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getchaintxstats",
  "params": [
    144,
    "0000000000000000000c1e1ecf0aef02b1c3d4c44c920afe0aaec7d08d0019e1"
  ]
}

{
  "result": {
    "time": 1700000000,
    "txcount": 889452301,
    "window_final_block_hash": "0000000000000000000c1e1ecf0aef02b1c3d4c44c920afe0aaec7d08d0019e1",
    "window_final_block_height": 855000,
    "window_block_count": 144,
    "window_tx_count": 17000,
    "window_interval": 11520,
    "txrate": 1.475
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getdifficulty

POST

https://qtum-blockbook.nownodes.io/

Returns the current difficulty as a multiple of the minimum difficulty (lowest possible difficulty on the network). This is a relative measure of how difficult it is to find a new block.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetdifficultyrequired

paramsarrayrequired

This method takes no parameters.

Response

200OK

Difficulty value returned successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getdifficulty

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getdifficulty",
    "params": []
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getdifficulty",
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getdifficulty",
  "params": []
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getdifficulty",
  "params": []
}

{
  "result": 8342150203598.12,
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getmempoolancestors

POST

https://qtum-blockbook.nownodes.io/

Returns all in-mempool ancestor transactions for a given transaction ID. An ancestor is a transaction whose outputs are used as inputs in another transaction. You can get a summary or detailed object output.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetmempoolancestorsrequired

paramsArray<string | boolean>required

Parameters:

txid (string, required) — Transaction ID to query.
verbose (boolean, optional) — Whether to return a JSON object or just an array of txids. Default is false.

Show child attributes

One of

string

boolean

Response

200OK

Ancestor transaction(s) retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getmempoolancestors

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getmempoolancestors",
    "params": [
      "txid_example",
      true
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getmempoolancestors",
      "params": [
        "txid_example",
        true
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmempoolancestors",
  "params": [
    "txid_example",
    true
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmempoolancestors",
  "params": [
    "txid_example",
    true
  ]
}

{
  "result": {
    "txid1": {
      "size": 250,
      "fee": 1000,
      "modifiedfee": 1000,
      "time": 1700000000,
      "height": 854998,
      "descendantcount": 1,
      "descendantsize": 600,
      "descendantfees": 3000,
      "ancestorcount": 1,
      "ancestorsize": 250,
      "ancestorfees": 1000,
      "depends": []
    },
    "txid2": "..."
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getmempooldescendants

POST

https://qtum-blockbook.nownodes.io/

Returns all in-mempool descendant transactions for a given transaction ID. Descendants are transactions that depend on the outputs of the specified transaction. Can return either a simple list of transaction IDs or detailed JSON objects.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetmempooldescendantsrequired

paramsArray<string | boolean>required

Parameters:

txid (string, required) — Transaction ID to query descendants for.
verbose (boolean, optional) — Return JSON object if true, or list of txids if false. Default: false.

Show child attributes

One of

string

boolean

Response

200OK

Descendant transactions retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getmempooldescendants

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getmempooldescendants",
    "params": [
      "txid_example",
      true
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getmempooldescendants",
      "params": [
        "txid_example",
        true
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmempooldescendants",
  "params": [
    "txid_example",
    true
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmempooldescendants",
  "params": [
    "txid_example",
    true
  ]
}

{
  "result": {
    "txid1": {
      "size": 300,
      "fee": 2000,
      "modifiedfee": 2100,
      "time": 1700000100,
      "height": 855000,
      "descendantcount": 0,
      "descendantsize": 0,
      "descendantfees": 0,
      "ancestorcount": 2,
      "ancestorsize": 600,
      "ancestorfees": 4000,
      "depends": [
        "txid_example"
      ]
    },
    "txid2": "..."
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getmempoolentry

POST

https://qtum-blockbook.nownodes.io/

Returns detailed information about a transaction currently in the mempool. Requires the transaction ID (txid) as a parameter.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetmempoolentryrequired

paramsArray<string>required

Parameters:

txid (string, required) — Transaction ID to query.

Response

200OK

Mempool entry details retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getmempoolentry

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getmempoolentry",
    "params": [
      "txid_example"
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getmempoolentry",
      "params": [
        "txid_example"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmempoolentry",
  "params": [
    "txid_example"
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmempoolentry",
  "params": [
    "txid_example"
  ]
}

{
  "result": {
    "size": 226,
    "fee": 1210,
    "modifiedfee": 1210,
    "time": 1699990000,
    "height": 854000,
    "descendantcount": 2,
    "descendantsize": 452,
    "descendantfees": 3000,
    "ancestorcount": 1,
    "ancestorsize": 226,
    "ancestorfees": 1210,
    "depends": []
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getmempoolinfo

POST

https://qtum-blockbook.nownodes.io/

Returns details about the current state of the mempool, including size, usage, fees, and more. No parameters required.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetmempoolinforequired

paramsArray<any>required

No parameters required

Response

200OK

Mempool info retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getmempoolinfo

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getmempoolinfo",
    "params": []
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getmempoolinfo",
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmempoolinfo",
  "params": []
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmempoolinfo",
  "params": []
}

{
  "result": {
    "size": 1240,
    "bytes": 987654,
    "usage": 1234567,
    "maxmempool": 300000000,
    "mempoolminfee": 0.00001,
    "minrelaytxfee": 0.00001,
    "maxfeerate": 0.1
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getrawmempool

POST

https://qtum-blockbook.nownodes.io/

Returns all transaction IDs currently in the mempool. If verbose is true, returns a JSON object with detailed mempool entry information for each transaction.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetrawmempoolrequired

paramsArray<boolean>required

Parameters:

verbose (boolean, optional) — If true, return detailed JSON objects instead of txid array. Default: false.

Response

200OK

Mempool transactions retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getrawmempool

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getrawmempool",
    "params": [
      true
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getrawmempool",
      "params": [
        true
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getrawmempool",
  "params": [
    true
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getrawmempool",
  "params": [
    true
  ]
}

{
  "result": {
    "txid1": {
      "size": 226,
      "fee": 1210,
      "time": 1699990000,
      "height": 854000,
      "startingpriority": 1000,
      "currentpriority": 950,
      "descendantcount": 2,
      "descendantsize": 452,
      "descendantfees": 3000,
      "ancestorcount": 1,
      "ancestorsize": 226,
      "ancestorfees": 1210,
      "depends": []
    }
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

gettxout

POST

https://qtum-blockbook.nownodes.io/

Returns details about an unspent transaction output (UTXO) specified by transaction ID and output index.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgettxoutrequired

paramsArray<string | integer | boolean>required

Parameters:

txid (string, required) — The transaction ID.
vout (integer, required) — The output index.
include_mempool (boolean, optional, default: true) — Whether to include mempool transactions.

Show child attributes

One of

string

integer

boolean

Response

200OK

UTXO details retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

gettxout

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "gettxout",
    "params": [
      "4e568274d63c824f5aa8215e2090d3dcfc97bf9922103dd06171ff779bd8cd5d",
      1,
      true
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "gettxout",
      "params": [
        "4e568274d63c824f5aa8215e2090d3dcfc97bf9922103dd06171ff779bd8cd5d",
        1,
        true
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "gettxout",
  "params": [
    "4e568274d63c824f5aa8215e2090d3dcfc97bf9922103dd06171ff779bd8cd5d",
    1,
    true
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "gettxout",
  "params": [
    "4e568274d63c824f5aa8215e2090d3dcfc97bf9922103dd06171ff779bd8cd5d",
    1,
    true
  ]
}

{
  "result": {
    "bestblock": "000000000000000000010927cae2186713052813554025f0b3c2d2a09f28ff91",
    "confirmations": 1,
    "value": 3.16459147,
    "scriptPubKey": {
      "asm": "OP_DUP OP_HASH160 6582f2551e2a47e1ae8b03fb666401ed7c4552ef OP_EQUALVERIFY OP_CHECKSIG",
      "hex": "a9146582f2551e2a47e1ae8b03fb666401ed7c4552ef87",
      "reqSigs": 1,
      "type": "scripthash",
      "addresses": [
        "3Awm3FNpmwrbvAFVThRUFqgpbVuqWisni9"
      ]
    },
    "coinbase": true
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

gettxoutproof

POST

https://qtum-blockbook.nownodes.io/

Returns a hex-encoded proof that one or more transactions are included in a block. The proof can be validated with verifytxoutproof.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgettxoutproofrequired

paramsArray<Array<string> | string>required

Parameters:

txids (array[string], required) — Array of transaction IDs to prove inclusion.
blockhash (string, optional) — Hash of the block to look for transactions. If omitted, searches the entire blockchain.

Show child attributes

One of

Array<string>

string

Response

200OK

Proof retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

gettxoutproof

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "gettxoutproof",
    "params": [
      [
        "ee652f0b40209bd02468de0c6336854f5efdd79fb865560aef2c46f4fa0b4a07",
        "cee11bc3bb3d9db8c4813ed2072a14369a15fcfb9e6bc5cb37a0b5bcc6aa59aa"
      ],
      null
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "gettxoutproof",
      "params": [
        [
          "ee652f0b40209bd02468de0c6336854f5efdd79fb865560aef2c46f4fa0b4a07",
          "cee11bc3bb3d9db8c4813ed2072a14369a15fcfb9e6bc5cb37a0b5bcc6aa59aa"
        ],
        null
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "gettxoutproof",
  "params": [
    [
      "ee652f0b40209bd02468de0c6336854f5efdd79fb865560aef2c46f4fa0b4a07",
      "cee11bc3bb3d9db8c4813ed2072a14369a15fcfb9e6bc5cb37a0b5bcc6aa59aa"
    ],
    null
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "gettxoutproof",
  "params": [
    [
      "ee652f0b40209bd02468de0c6336854f5efdd79fb865560aef2c46f4fa0b4a07",
      "cee11bc3bb3d9db8c4813ed2072a14369a15fcfb9e6bc5cb37a0b5bcc6aa59aa"
    ],
    null
  ]
}

{
  "result": "000000202834abd71bdd0d3298542af4506918ea168ce002936b040000000000000000001da8757e4d756e848245cacf3e103c1b9f6ed2405c6d818a73172c8ec72856d4db3864606fdf0c17dcc1000ccb0300000cb86343fc64abcdab51e530303a4ee2b420fa6b5a12b435c9c76fe953ca5471ca074a0bfaf4462cef0a5665b89fd7fd5e4f8536630cde6824d09b20400b2f65eed9f744b2dc695b0ea0c4afd06310a21b93ddd7270a781acd0ada1afdd23b5750aa59aac6bcb5a037cbc56b9efbfc159a36142a07d23e81c4b89d3dbbc31be1cefe0bb7b0369ffc3b1d530e234987543a2613bbb8b06c86f993a930dee7b9d87f661ef556adc0174c7f180aa28006ee93ce2291302801ecd045c234c00b186ea35ff1e77eac3f113492e2eb12f38b9df452f5831f55c861865ac8f3c7dd06be2377f859ba1d12dea2ec44987796a27d42d5727250c1e0181d6a251f8272f21b9a2034069a2471de43de655619904d43b4665f6ce38741320998dc97838c32c79f1ada066ddf7a441357d55cc42a8906970bff2d5342be694002476733ff593af26f320c10df7ba9a76355438f462c040b598868dfb67c5e88d6d9a426ec8cdd74337d42df6b29e9fb319410848f3ff7228d00dc539e2962d185348ab9663a112a03ff6e00",
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

preciousblock

POST

https://qtum-blockbook.nownodes.io/

Marks a block as "precious," causing the node to reconsider the chain from that block. This can be used to manually reorganize the chain to a particular fork.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringpreciousblockrequired

paramsArray<string>required

Parameters:

blockhash (string, required) — The hash of the block to mark as precious.

Response

200OK

Block marked as precious successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

preciousblock

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "preciousblock",
    "params": [
      "0000000000000000000a7b89e4d3f3bcebd7025fa72d2d9c7b3e8f7a3bc5c8a5"
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "preciousblock",
      "params": [
        "0000000000000000000a7b89e4d3f3bcebd7025fa72d2d9c7b3e8f7a3bc5c8a5"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "preciousblock",
  "params": [
    "0000000000000000000a7b89e4d3f3bcebd7025fa72d2d9c7b3e8f7a3bc5c8a5"
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "preciousblock",
  "params": [
    "0000000000000000000a7b89e4d3f3bcebd7025fa72d2d9c7b3e8f7a3bc5c8a5"
  ]
}

{
  "result": null,
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

TESTNET / Blockchain_RPCs

getbestblockhash

POST

https://qtum-blockbook.nownodes.io/

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetbestblockhashrequired

paramsArray<any>required

Response

200OK

Valid response

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getbestblockhash

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getbestblockhash",
    "params": []
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getbestblockhash",
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getbestblockhash",
  "params": []
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getbestblockhash",
  "params": []
}

{
  "result": "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getblock

POST

https://qtum-blockbook.nownodes.io/

Returns information about the block with the given block hash. Optional verbosity levels determine the level of detail in the response:

0: Returns a string that is serialized, hex-encoded data for the block.
1: Returns a JSON object with basic block details and txids.
2: Returns a JSON object with detailed transaction info.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetblockrequired

paramsArray<string | integer>required

Parameters:

blockhash (string) – The hash of the block
verbosity (integer, optional) – Level of detail: 0, 1, or 2

Show child attributes

One of

string

integer

Response

200OK

Block information retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getblock

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getblock",
    "params": [
      "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
      1
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getblock",
      "params": [
        "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
        1
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblock",
  "params": [
    "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
    1
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblock",
  "params": [
    "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
    1
  ]
}

{
  "result": {
    "hash": "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
    "confirmations": 100,
    "height": 855000,
    "version": 536870912,
    "versionHex": "20000000",
    "merkleroot": "a3e1f3...ff9a",
    "time": 1700000000,
    "mediantime": 1699995000,
    "nonce": 4282073135,
    "bits": "170d1f5d",
    "difficulty": 225983213292.9388,
    "chainwork": "0000000000000000000000000000000000000000230c36f8ff7f4fbee5b6a0c2",
    "previousblockhash": "0000000000000000000c1e1ecf0aef02b1c3d4c44c920afe0aaec7d08d0019e1",
    "nextblockhash": "0000000000000000000735c64b80cd102b8e4d67c2cc09db81fa4451a6f58e3a",
    "tx": [
      "string"
    ]
  },
  "error": {},
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getblockchaininfo

POST

https://qtum-blockbook.nownodes.io/

Returns an object containing various state info regarding blockchain processing.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetblockchaininforequired

paramsArray<any>required

Response

200OK

Blockchain state information retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getblockchaininfo

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getblockchaininfo",
    "params": []
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getblockchaininfo",
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblockchaininfo",
  "params": []
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblockchaininfo",
  "params": []
}

{
  "result": {
    "chain": "main",
    "blocks": 855000,
    "headers": 855002,
    "bestblockhash": "0000000000000000000b27d455de872dfe8a8aa4f2efbfc5f1877357f7c8e97b",
    "difficulty": 225983213292.9388,
    "mediantime": 1700000500,
    "verificationprogress": 0.999999,
    "initialblockdownload": false,
    "chainwork": "0000000000000000000000000000000000000000230c36f8ff7f4fbee5b6a0c2",
    "size_on_disk": 495000000000,
    "pruned": false,
    "pruneheight": null,
    "automatic_pruning": false,
    "prune_target_size": null,
    "warnings": ""
  },
  "error": {},
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getblockcount

POST

https://qtum-blockbook.nownodes.io/

Returns the number of blocks in the longest blockchain. This number increases as new blocks are added.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetblockcountrequired

paramsarrayrequired

This method takes no parameters.

Response

200OK

Current block height retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getblockcount

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getblockcount",
    "params": []
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getblockcount",
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblockcount",
  "params": []
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblockcount",
  "params": []
}

{
  "result": 855000,
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getblockhash

POST

https://qtum-blockbook.nownodes.io/

Returns the block hash of the block at the given height in the blockchain. You must provide a block height (0-based index).

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetblockhashrequired

paramsArray<integer>required

Parameters:

height (integer) — The height (index) of the block.

Response

200OK

Block hash successfully retrieved

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getblockhash

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getblockhash",
    "params": [
      855000
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getblockhash",
      "params": [
        855000
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblockhash",
  "params": [
    855000
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblockhash",
  "params": [
    855000
  ]
}

{
  "result": "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getblockheader

POST

https://qtum-blockbook.nownodes.io/

Returns information about the block header given a block hash. You can specify whether to return a JSON object or raw hex-encoded string using the verbose flag.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetblockheaderrequired

paramsArray<string | boolean>required

Parameters:

blockhash (string) — The hash of the block.
verbose (boolean, optional) — If true, returns a JSON object; if false, returns a hex string. Default is true.

Show child attributes

One of

string

boolean

Response

200OK

Block header information retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getblockheader

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getblockheader",
    "params": [
      "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
      true
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getblockheader",
      "params": [
        "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
        true
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblockheader",
  "params": [
    "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
    true
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblockheader",
  "params": [
    "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
    true
  ]
}

{
  "result": {
    "hash": "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
    "confirmations": 105,
    "height": 855000,
    "version": 536870912,
    "versionHex": "20000000",
    "merkleroot": "e3abc1234...",
    "time": 1700000000,
    "mediantime": 1699995000,
    "nonce": 1234567890,
    "bits": "170d1f5d",
    "difficulty": 225983213292.9388,
    "chainwork": "0000000000000000000000000000000000000000230c36f8ff7f4fbee5b6a0c2",
    "previousblockhash": "0000000000000000000c1e1ecf0aef02b1c3d4c44c920afe0aaec7d08d0019e1",
    "nextblockhash": "0000000000000000000735c64b80cd102b8e4d67c2cc09db81fa4451a6f58e3a"
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getblockstats

POST

https://qtum-blockbook.nownodes.io/

Returns a variety of statistics about the block identified by its height or block hash.

Body

application/json

jsonrpcstring1.02.0required

JSON-RPC protocol version.

methodstringgetblockstatsrequired

Name of the RPC method.

paramsArray<integer>

Parameters for the method. For getblockstats, this is an array containing a single value – either the block height (integer) or block hash (string).

idstringrequired

Request identifier. The response will echo this value. Can be any string or number.

Response

200OK

Successful block statistics retrieval.

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getblockstats

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "method": "getblockstats",
    "params": [
      855000
    ],
    "id": "curltest"
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "method": "getblockstats",
      "params": [
        855000
      ],
      "id": "curltest"
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "method": "getblockstats",
  "params": [
    855000
  ],
  "id": "curltest"
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getblockstats",
  "params": [
    855000
  ]
}

{
  "result": {
    "avgfee": 2506,
    "avgfeerate": 5,
    "avgtxsize": 758,
    "blockhash": "0000000000000000000233ea80aa10d38aa4486cd7033fffc2c4df556d0b9138",
    "feerate_percentiles": [
      3,
      3,
      4,
      5,
      7
    ],
    "height": 855000,
    "ins": 9241,
    "maxfee": 315273,
    "maxfeerate": 974,
    "maxtxsize": 208603,
    "medianfee": 717,
    "mediantime": 1722542196,
    "mediantxsize": 223,
    "minfee": 143,
    "minfeerate": 1,
    "mintxsize": 150,
    "outs": 7778,
    "subsidy": 312500000,
    "swtotal_size": 1662368,
    "swtotal_weight": 3546428,
    "swtxs": 2189,
    "time": 1722544444,
    "total_out": 784184758176,
    "total_size": 1773719,
    "total_weight": 3991832,
    "totalfee": 5858578,
    "txs": 2338,
    "utxo_increase": -1463,
    "utxo_size_inc": -107691,
    "utxo_increase_actual": -2000,
    "utxo_size_inc_actual": -139944
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getchaintips

POST

https://qtum-blockbook.nownodes.io/

Returns information about all known tips in the block tree, including the main chain as well as orphaned forks.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetchaintipsrequired

paramsarrayrequired

This method takes no parameters.

Response

200OK

Chain tips retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getchaintips

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getchaintips",
    "params": []
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getchaintips",
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getchaintips",
  "params": []
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getchaintips",
  "params": []
}

{
  "result": [
    {
      "height": 855000,
      "hash": "0000000000000000000a1e63be6bb1d1f4e6d2a345234a4a6b8f86e4f0de3c5a",
      "branchlen": 0,
      "status": "active"
    },
    {
      "height": 854980,
      "hash": "0000000000000000000f83a8e9a563e48e7b8e5400e38310ff299b7f30aaf8d9",
      "branchlen": 20,
      "status": "valid-fork"
    }
  ],
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getchaintxstats

POST

https://qtum-blockbook.nownodes.io/

Compute statistics about the total number and rate of transactions in the blockchain. You can optionally specify the number of blocks and a block hash to start from.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetchaintxstatsrequired

paramsArray<integer | string>required

Parameters:

nblocks (integer, optional) — Number of blocks to average over. Default: 1 month worth (~4320).
blockhash (string, optional) — Hash of the block to stop at; defaults to the chain tip.

Show child attributes

One of

integer

string

Response

200OK

Chain transaction statistics retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getchaintxstats

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getchaintxstats",
    "params": [
      144,
      "0000000000000000000c1e1ecf0aef02b1c3d4c44c920afe0aaec7d08d0019e1"
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getchaintxstats",
      "params": [
        144,
        "0000000000000000000c1e1ecf0aef02b1c3d4c44c920afe0aaec7d08d0019e1"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getchaintxstats",
  "params": [
    144,
    "0000000000000000000c1e1ecf0aef02b1c3d4c44c920afe0aaec7d08d0019e1"
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getchaintxstats",
  "params": [
    144,
    "0000000000000000000c1e1ecf0aef02b1c3d4c44c920afe0aaec7d08d0019e1"
  ]
}

{
  "result": {
    "time": 1700000000,
    "txcount": 889452301,
    "window_final_block_hash": "0000000000000000000c1e1ecf0aef02b1c3d4c44c920afe0aaec7d08d0019e1",
    "window_final_block_height": 855000,
    "window_block_count": 144,
    "window_tx_count": 17000,
    "window_interval": 11520,
    "txrate": 1.475
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getdifficulty

POST

https://qtum-blockbook.nownodes.io/

Returns the current difficulty as a multiple of the minimum difficulty (lowest possible difficulty on the network). This is a relative measure of how difficult it is to find a new block.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetdifficultyrequired

paramsarrayrequired

This method takes no parameters.

Response

200OK

Difficulty value returned successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getdifficulty

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getdifficulty",
    "params": []
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getdifficulty",
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getdifficulty",
  "params": []
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getdifficulty",
  "params": []
}

{
  "result": 8342150203598.12,
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getmempoolancestors

POST

https://qtum-blockbook.nownodes.io/

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetmempoolancestorsrequired

paramsArray<string | boolean>required

Parameters:

txid (string, required) — Transaction ID to query.
verbose (boolean, optional) — Whether to return a JSON object or just an array of txids. Default is false.

Show child attributes

One of

string

boolean

Response

200OK

Ancestor transaction(s) retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getmempoolancestors

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getmempoolancestors",
    "params": [
      "txid_example",
      true
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getmempoolancestors",
      "params": [
        "txid_example",
        true
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmempoolancestors",
  "params": [
    "txid_example",
    true
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmempoolancestors",
  "params": [
    "txid_example",
    true
  ]
}

{
  "result": {
    "txid1": {
      "size": 250,
      "fee": 1000,
      "modifiedfee": 1000,
      "time": 1700000000,
      "height": 854998,
      "descendantcount": 1,
      "descendantsize": 600,
      "descendantfees": 3000,
      "ancestorcount": 1,
      "ancestorsize": 250,
      "ancestorfees": 1000,
      "depends": []
    },
    "txid2": "..."
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getmempooldescendants

POST

https://qtum-blockbook.nownodes.io/

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetmempooldescendantsrequired

paramsArray<string | boolean>required

Parameters:

txid (string, required) — Transaction ID to query descendants for.
verbose (boolean, optional) — Return JSON object if true, or list of txids if false. Default: false.

Show child attributes

One of

string

boolean

Response

200OK

Descendant transactions retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getmempooldescendants

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getmempooldescendants",
    "params": [
      "txid_example",
      true
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getmempooldescendants",
      "params": [
        "txid_example",
        true
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmempooldescendants",
  "params": [
    "txid_example",
    true
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmempooldescendants",
  "params": [
    "txid_example",
    true
  ]
}

{
  "result": {
    "txid1": {
      "size": 300,
      "fee": 2000,
      "modifiedfee": 2100,
      "time": 1700000100,
      "height": 855000,
      "descendantcount": 0,
      "descendantsize": 0,
      "descendantfees": 0,
      "ancestorcount": 2,
      "ancestorsize": 600,
      "ancestorfees": 4000,
      "depends": [
        "txid_example"
      ]
    },
    "txid2": "..."
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getmempoolentry

POST

https://qtum-blockbook.nownodes.io/

Returns detailed information about a transaction currently in the mempool. Requires the transaction ID (txid) as a parameter.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetmempoolentryrequired

paramsArray<string>required

Parameters:

txid (string, required) — Transaction ID to query.

Response

200OK

Mempool entry details retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getmempoolentry

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getmempoolentry",
    "params": [
      "txid_example"
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getmempoolentry",
      "params": [
        "txid_example"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmempoolentry",
  "params": [
    "txid_example"
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmempoolentry",
  "params": [
    "txid_example"
  ]
}

{
  "result": {
    "size": 226,
    "fee": 1210,
    "modifiedfee": 1210,
    "time": 1699990000,
    "height": 854000,
    "descendantcount": 2,
    "descendantsize": 452,
    "descendantfees": 3000,
    "ancestorcount": 1,
    "ancestorsize": 226,
    "ancestorfees": 1210,
    "depends": []
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getmempoolinfo

POST

https://qtum-blockbook.nownodes.io/

Returns details about the current state of the mempool, including size, usage, fees, and more. No parameters required.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetmempoolinforequired

paramsArray<any>required

No parameters required

Response

200OK

Mempool info retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getmempoolinfo

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getmempoolinfo",
    "params": []
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getmempoolinfo",
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmempoolinfo",
  "params": []
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmempoolinfo",
  "params": []
}

{
  "result": {
    "size": 1240,
    "bytes": 987654,
    "usage": 1234567,
    "maxmempool": 300000000,
    "mempoolminfee": 0.00001,
    "minrelaytxfee": 0.00001,
    "maxfeerate": 0.1
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getrawmempool

POST

https://qtum-blockbook.nownodes.io/

Returns all transaction IDs currently in the mempool. If verbose is true, returns a JSON object with detailed mempool entry information for each transaction.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetrawmempoolrequired

paramsArray<boolean>required

Parameters:

verbose (boolean, optional) — If true, return detailed JSON objects instead of txid array. Default: false.

Response

200OK

Mempool transactions retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getrawmempool

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getrawmempool",
    "params": [
      true
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getrawmempool",
      "params": [
        true
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getrawmempool",
  "params": [
    true
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getrawmempool",
  "params": [
    true
  ]
}

{
  "result": {
    "txid1": {
      "size": 226,
      "fee": 1210,
      "time": 1699990000,
      "height": 854000,
      "startingpriority": 1000,
      "currentpriority": 950,
      "descendantcount": 2,
      "descendantsize": 452,
      "descendantfees": 3000,
      "ancestorcount": 1,
      "ancestorsize": 226,
      "ancestorfees": 1210,
      "depends": []
    }
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

gettxout

POST

https://qtum-blockbook.nownodes.io/

Returns details about an unspent transaction output (UTXO) specified by transaction ID and output index.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgettxoutrequired

paramsArray<string | integer | boolean>required

Parameters:

txid (string, required) — The transaction ID.
vout (integer, required) — The output index.
include_mempool (boolean, optional, default: true) — Whether to include mempool transactions.

Show child attributes

One of

string

integer

boolean

Response

200OK

UTXO details retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

gettxout

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "gettxout",
    "params": [
      "4e568274d63c824f5aa8215e2090d3dcfc97bf9922103dd06171ff779bd8cd5d",
      1,
      true
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "gettxout",
      "params": [
        "4e568274d63c824f5aa8215e2090d3dcfc97bf9922103dd06171ff779bd8cd5d",
        1,
        true
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "gettxout",
  "params": [
    "4e568274d63c824f5aa8215e2090d3dcfc97bf9922103dd06171ff779bd8cd5d",
    1,
    true
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "gettxout",
  "params": [
    "4e568274d63c824f5aa8215e2090d3dcfc97bf9922103dd06171ff779bd8cd5d",
    1,
    true
  ]
}

{
  "result": {
    "bestblock": "000000000000000000010927cae2186713052813554025f0b3c2d2a09f28ff91",
    "confirmations": 1,
    "value": 3.16459147,
    "scriptPubKey": {
      "asm": "OP_DUP OP_HASH160 6582f2551e2a47e1ae8b03fb666401ed7c4552ef OP_EQUALVERIFY OP_CHECKSIG",
      "hex": "a9146582f2551e2a47e1ae8b03fb666401ed7c4552ef87",
      "reqSigs": 1,
      "type": "scripthash",
      "addresses": [
        "3Awm3FNpmwrbvAFVThRUFqgpbVuqWisni9"
      ]
    },
    "coinbase": true
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

gettxoutproof

POST

https://qtum-blockbook.nownodes.io/

Returns a hex-encoded proof that one or more transactions are included in a block. The proof can be validated with verifytxoutproof.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgettxoutproofrequired

paramsArray<Array<string> | string>required

Parameters:

txids (array[string], required) — Array of transaction IDs to prove inclusion.
blockhash (string, optional) — Hash of the block to look for transactions. If omitted, searches the entire blockchain.

Show child attributes

One of

Array<string>

string

Response

200OK

Proof retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

gettxoutproof

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "gettxoutproof",
    "params": [
      [
        "ee652f0b40209bd02468de0c6336854f5efdd79fb865560aef2c46f4fa0b4a07",
        "cee11bc3bb3d9db8c4813ed2072a14369a15fcfb9e6bc5cb37a0b5bcc6aa59aa"
      ],
      null
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "gettxoutproof",
      "params": [
        [
          "ee652f0b40209bd02468de0c6336854f5efdd79fb865560aef2c46f4fa0b4a07",
          "cee11bc3bb3d9db8c4813ed2072a14369a15fcfb9e6bc5cb37a0b5bcc6aa59aa"
        ],
        null
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "gettxoutproof",
  "params": [
    [
      "ee652f0b40209bd02468de0c6336854f5efdd79fb865560aef2c46f4fa0b4a07",
      "cee11bc3bb3d9db8c4813ed2072a14369a15fcfb9e6bc5cb37a0b5bcc6aa59aa"
    ],
    null
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "gettxoutproof",
  "params": [
    [
      "ee652f0b40209bd02468de0c6336854f5efdd79fb865560aef2c46f4fa0b4a07",
      "cee11bc3bb3d9db8c4813ed2072a14369a15fcfb9e6bc5cb37a0b5bcc6aa59aa"
    ],
    null
  ]
}

{
  "result": "000000202834abd71bdd0d3298542af4506918ea168ce002936b040000000000000000001da8757e4d756e848245cacf3e103c1b9f6ed2405c6d818a73172c8ec72856d4db3864606fdf0c17dcc1000ccb0300000cb86343fc64abcdab51e530303a4ee2b420fa6b5a12b435c9c76fe953ca5471ca074a0bfaf4462cef0a5665b89fd7fd5e4f8536630cde6824d09b20400b2f65eed9f744b2dc695b0ea0c4afd06310a21b93ddd7270a781acd0ada1afdd23b5750aa59aac6bcb5a037cbc56b9efbfc159a36142a07d23e81c4b89d3dbbc31be1cefe0bb7b0369ffc3b1d530e234987543a2613bbb8b06c86f993a930dee7b9d87f661ef556adc0174c7f180aa28006ee93ce2291302801ecd045c234c00b186ea35ff1e77eac3f113492e2eb12f38b9df452f5831f55c861865ac8f3c7dd06be2377f859ba1d12dea2ec44987796a27d42d5727250c1e0181d6a251f8272f21b9a2034069a2471de43de655619904d43b4665f6ce38741320998dc97838c32c79f1ada066ddf7a441357d55cc42a8906970bff2d5342be694002476733ff593af26f320c10df7ba9a76355438f462c040b598868dfb67c5e88d6d9a426ec8cdd74337d42df6b29e9fb319410848f3ff7228d00dc539e2962d185348ab9663a112a03ff6e00",
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

preciousblock

POST

https://qtum-blockbook.nownodes.io/

Marks a block as "precious," causing the node to reconsider the chain from that block. This can be used to manually reorganize the chain to a particular fork.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringpreciousblockrequired

paramsArray<string>required

Parameters:

blockhash (string, required) — The hash of the block to mark as precious.

Response

200OK

Block marked as precious successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

preciousblock

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "preciousblock",
    "params": [
      "0000000000000000000a7b89e4d3f3bcebd7025fa72d2d9c7b3e8f7a3bc5c8a5"
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "preciousblock",
      "params": [
        "0000000000000000000a7b89e4d3f3bcebd7025fa72d2d9c7b3e8f7a3bc5c8a5"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "preciousblock",
  "params": [
    "0000000000000000000a7b89e4d3f3bcebd7025fa72d2d9c7b3e8f7a3bc5c8a5"
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "preciousblock",
  "params": [
    "0000000000000000000a7b89e4d3f3bcebd7025fa72d2d9c7b3e8f7a3bc5c8a5"
  ]
}

{
  "result": null,
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

MAINNET / Mining_RPCs

getmininginfo

POST

https://qtum-blockbook.nownodes.io/

Returns mining-related information such as current block, difficulty, network hash rate, etc. No parameters are required.

Body

application/json

jsonrpcstringrequired

JSON-RPC version (always "1.0")

idstringrequired

Request identifier

methodstringgetmininginforequired

The RPC method name

paramsarrayrequired

No parameters required

Response

200OK

Mining info retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getmininginfo

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getmininginfo",
    "params": []
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getmininginfo",
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmininginfo",
  "params": []
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmininginfo",
  "params": []
}

{
  "result": {
    "blocks": 854000,
    "currentblockweight": 3990000,
    "currentblocktx": 2450,
    "difficulty": 568382716485.9244,
    "networkhashps": 130000000000000,
    "pooledtx": 5421,
    "chain": "main",
    "warnings": ""
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getnetworkhashps

POST

https://qtum-blockbook.nownodes.io/

Returns the estimated network hashes per second (hash rate) based on the last nblocks blocks. This provides an estimate of the total computational power securing the network.

Body

application/json

jsonrpcstringrequired

The JSON-RPC protocol version (always "1.0")

idstringrequired

The identifier for the request

methodstringgetnetworkhashpsrequired

The name of the RPC method

paramsArray<integer>required

Optional parameters:

nblocks (integer) — The number of blocks to average over. Default is 120.
height (integer) — Use the block at this height instead of the current tip. Use -1 for the tip.

Show child attributes

One of

integer

Response

200OK

Hash rate retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getnetworkhashps

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getnetworkhashps",
    "params": [
      120,
      -1
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getnetworkhashps",
      "params": [
        120,
        -1
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getnetworkhashps",
  "params": [
    120,
    -1
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getnetworkhashps",
  "params": [
    120,
    -1
  ]
}

{
  "result": 134567890123456.78,
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

TESTNET / Mining_RPCs

getmininginfo

POST

https://qtum-blockbook.nownodes.io/

Returns mining-related information such as current block, difficulty, network hash rate, etc. No parameters are required.

Body

application/json

jsonrpcstringrequired

JSON-RPC version (always "1.0")

idstringrequired

Request identifier

methodstringgetmininginforequired

The RPC method name

paramsarrayrequired

No parameters required

Response

200OK

Mining info retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getmininginfo

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getmininginfo",
    "params": []
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getmininginfo",
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmininginfo",
  "params": []
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getmininginfo",
  "params": []
}

{
  "result": {
    "blocks": 854000,
    "currentblockweight": 3990000,
    "currentblocktx": 2450,
    "difficulty": 568382716485.9244,
    "networkhashps": 130000000000000,
    "pooledtx": 5421,
    "chain": "main",
    "warnings": ""
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getnetworkhashps

POST

https://qtum-blockbook.nownodes.io/

Returns the estimated network hashes per second (hash rate) based on the last nblocks blocks. This provides an estimate of the total computational power securing the network.

Body

application/json

jsonrpcstringrequired

The JSON-RPC protocol version (always "1.0")

idstringrequired

The identifier for the request

methodstringgetnetworkhashpsrequired

The name of the RPC method

paramsArray<integer>required

Optional parameters:

nblocks (integer) — The number of blocks to average over. Default is 120.
height (integer) — Use the block at this height instead of the current tip. Use -1 for the tip.

Show child attributes

One of

integer

Response

200OK

Hash rate retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getnetworkhashps

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getnetworkhashps",
    "params": [
      120,
      -1
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getnetworkhashps",
      "params": [
        120,
        -1
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getnetworkhashps",
  "params": [
    120,
    -1
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getnetworkhashps",
  "params": [
    120,
    -1
  ]
}

{
  "result": 134567890123456.78,
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

MAINNET / Rawtransactions_RPCs

createrawtransaction

POST

https://qtum-blockbook.nownodes.io/

Creates an unsigned raw transaction from a list of inputs and outputs. The transaction is returned as a serialized hex string, which can then be signed and broadcast.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringcreaterawtransactionrequired

paramsArray<Array<object> | object | integer | boolean>required

Parameters:

inputs (array) — List of transaction inputs, each including txid and vout.
outputs (object) — Destination addresses and amounts.
locktime (integer, optional) — Locktime value.
replaceable (boolean, optional) — Whether this transaction signals BIP125 replaceability.

Show child attributes

One of

Array<object>

Show child attributes

txidstring

Transaction ID to spend

voutinteger

Output index

object

integer

boolean

Response

200OK

Unsigned raw transaction created successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

createrawtransaction

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "createrawtransaction",
    "params": [
      [
        {
          "txid": "my_txid_here",
          "vout": 0
        }
      ],
      {
        "bc1qrecipientaddress...": 0.001
      }
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "createrawtransaction",
      "params": [
        [
          {
            "txid": "my_txid_here",
            "vout": 0
          }
        ],
        {
          "bc1qrecipientaddress...": 0.001
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "createrawtransaction",
  "params": [
    [
      {
        "txid": "my_txid_here",
        "vout": 0
      }
    ],
    {
      "bc1qrecipientaddress...": 0.001
    }
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "createrawtransaction",
  "params": [
    [
      {
        "txid": "my_txid_here",
        "vout": 0
      }
    ],
    {
      "bc1qrecipientaddress...": 0.001
    }
  ]
}

{
  "result": "0200000001abcd...00000000",
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

decoderawtransaction

POST

https://qtum-blockbook.nownodes.io/

Decodes a raw hex-encoded Bitcoin transaction and returns a JSON object with readable fields. Useful for viewing the contents of raw transactions before broadcasting.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringdecoderawtransactionrequired

paramsArray<string>required

Parameters:

hexstring (string, required) — The raw transaction hex string.

Response

200OK

Transaction decoded successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

decoderawtransaction

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "decoderawtransaction",
    "params": [
      "0200000001abcd...00000000"
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "decoderawtransaction",
      "params": [
        "0200000001abcd...00000000"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "decoderawtransaction",
  "params": [
    "0200000001abcd...00000000"
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "decoderawtransaction",
  "params": [
    "0200000001abcd...00000000"
  ]
}

{
  "result": {
    "txid": "abcd1234...",
    "hash": "abcd1234...",
    "version": 2,
    "size": 225,
    "vsize": 144,
    "locktime": 0,
    "vin": [
      {
        "txid": "input_txid",
        "vout": 0,
        "scriptSig": {
          "asm": "asm_code",
          "hex": "hex_code"
        },
        "sequence": 4294967295
      }
    ],
    "vout": [
      {
        "value": 0.001,
        "n": 0,
        "scriptPubKey": {
          "asm": "asm_output",
          "hex": "hex_output",
          "type": "witness_v0_keyhash",
          "addresses": [
            "bc1q..."
          ]
        }
      }
    ]
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

decodescript

POST

https://qtum-blockbook.nownodes.io/

Decodes a hex-encoded script (usually scriptPubKey) and returns a JSON representation including the script type and addresses. Useful for analyzing output scripts or creating Pay-to-Script-Hash addresses.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

idstringrequired

Request identifier

methodstringdecodescriptrequired

RPC method name

paramsArray<string>required

Parameters:

hexstring (string, required) — The script in hex format to decode.

Response

200OK

Script decoded successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

decodescript

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "decodescript",
    "params": [
      "00141d0f172a0ecb48aee1be1f2687d2963ae33f71a1"
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "decodescript",
      "params": [
        "00141d0f172a0ecb48aee1be1f2687d2963ae33f71a1"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "decodescript",
  "params": [
    "00141d0f172a0ecb48aee1be1f2687d2963ae33f71a1"
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "decodescript",
  "params": [
    "00141d0f172a0ecb48aee1be1f2687d2963ae33f71a1"
  ]
}

{
  "result": {
    "asm": "OP_0 1d0f172a0ecb48aee1be1f2687d2963ae33f71a1",
    "type": "witness_v0_keyhash",
    "reqSigs": 1,
    "addresses": [
      "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080"
    ],
    "p2sh": "3QJmV3qfvL9SuYo34YihAf3sRCW3qSinyC"
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getrawtransaction

POST

https://qtum-blockbook.nownodes.io/

Retrieves a raw transaction by its txid. If verbose is false or omitted, the result is a raw hex string. If verbose is true, returns a JSON object with decoded transaction details.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetrawtransactionrequired

paramsArray<string | boolean>required

Parameters:

txid (string, required) — The transaction ID.
verbose (boolean, optional) — If true, return JSON; if false, return hex. Default: false.

Show child attributes

One of

string

boolean

Response

200OK

Transaction retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getrawtransaction

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getrawtransaction",
    "params": [
      "txid_here",
      true
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getrawtransaction",
      "params": [
        "txid_here",
        true
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getrawtransaction",
  "params": [
    "txid_here",
    true
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getrawtransaction",
  "params": [
    "txid_here",
    true
  ]
}

{
  "result": "0200000001abcd...00000000",
  "error": null,
  "id": "curltest"
}

{
  "result": {
    "txid": "abcd1234...",
    "hash": "abcd1234...",
    "version": 2,
    "size": 225,
    "vsize": 144,
    "locktime": 0,
    "vin": [
      "..."
    ],
    "vout": [
      "..."
    ],
    "hex": "0200000001abcd...00000000"
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

sendrawtransaction

POST

https://qtum-blockbook.nownodes.io/

Submits a raw transaction (hex-encoded string) to the mempool and broadcasts it to the network. Returns the transaction ID (txid) if accepted.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringsendrawtransactionrequired

paramsArray<string | number | boolean>required

Parameters:

hexstring (string, required): The raw transaction in hex format.
maxfeerate (number or boolean, optional): Reject transactions with fees higher than this (BTC/KB). Use false to disable check.

Show child attributes

One of

string

number

boolean

Response

200OK

Transaction accepted and broadcasted

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

sendrawtransaction

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "sendrawtransaction",
    "params": [
      "0200000001abcd...00000000",
      false
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "sendrawtransaction",
      "params": [
        "0200000001abcd...00000000",
        false
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "sendrawtransaction",
  "params": [
    "0200000001abcd...00000000",
    false
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "sendrawtransaction",
  "params": [
    "0200000001abcd...00000000",
    false
  ]
}

{
  "result": "abcd1234txid",
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

signrawtransactionwithkey

POST

https://qtum-blockbook.nownodes.io/

Signs inputs for a raw transaction using explicitly provided private keys, without needing access to a local wallet. Useful for offline signing or stateless transaction construction.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringsignrawtransactionwithkeyrequired

paramsArray<string | Array<string> | Array<object>>required

Parameters:

hexstring (string, required): The raw transaction hex string.
privkeys (array of strings, required): Array of WIF private keys.
prevtxs (array, optional): Array of previous output details for inputs to sign.

Show child attributes

One of

string

Array<string>

Array<object>

Show child attributes

txidstring

Transaction ID of the UTXO being spent.

voutinteger

Output index.

scriptPubKeystring

Script of the UTXO.

redeemScriptstring

(optional) Redeem script for P2SH inputs.

witnessScriptstring

(optional) Witness script for P2WSH inputs.

amountnumber

Amount in BTC of the UTXO.

Response

200OK

Transaction signed successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

signrawtransactionwithkey

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "signrawtransactionwithkey",
    "params": [
      "0200000001abcd...00000000",
      [
        "cV...yourWIFkey..."
      ],
      [
        {
          "txid": "abcd1234...",
          "vout": 0,
          "scriptPubKey": "76a914...88ac",
          "redeemScript": "0020...",
          "amount": 0.001
        }
      ]
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "signrawtransactionwithkey",
      "params": [
        "0200000001abcd...00000000",
        [
          "cV...yourWIFkey..."
        ],
        [
          {
            "txid": "abcd1234...",
            "vout": 0,
            "scriptPubKey": "76a914...88ac",
            "redeemScript": "0020...",
            "amount": 0.001
          }
        ]
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "signrawtransactionwithkey",
  "params": [
    "0200000001abcd...00000000",
    [
      "cV...yourWIFkey..."
    ],
    [
      {
        "txid": "abcd1234...",
        "vout": 0,
        "scriptPubKey": "76a914...88ac",
        "redeemScript": "0020...",
        "amount": 0.001
      }
    ]
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "signrawtransactionwithkey",
  "params": [
    "0200000001abcd...00000000",
    [
      "cV...yourWIFkey..."
    ],
    [
      {
        "txid": "abcd1234...",
        "vout": 0,
        "scriptPubKey": "76a914...88ac",
        "redeemScript": "0020...",
        "amount": 0.001
      }
    ]
  ]
}

{
  "result": {
    "hex": "0200000001abcd...00000000",
    "complete": true,
    "errors": []
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

TESTNET / Rawtransactions_RPCs

createrawtransaction

POST

https://qtum-blockbook.nownodes.io/

Creates an unsigned raw transaction from a list of inputs and outputs. The transaction is returned as a serialized hex string, which can then be signed and broadcast.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringcreaterawtransactionrequired

paramsArray<Array<object> | object | integer | boolean>required

Parameters:

inputs (array) — List of transaction inputs, each including txid and vout.
outputs (object) — Destination addresses and amounts.
locktime (integer, optional) — Locktime value.
replaceable (boolean, optional) — Whether this transaction signals BIP125 replaceability.

Show child attributes

One of

Array<object>

Show child attributes

txidstring

Transaction ID to spend

voutinteger

Output index

object

integer

boolean

Response

200OK

Unsigned raw transaction created successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

createrawtransaction

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "createrawtransaction",
    "params": [
      [
        {
          "txid": "my_txid_here",
          "vout": 0
        }
      ],
      {
        "bc1qrecipientaddress...": 0.001
      }
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "createrawtransaction",
      "params": [
        [
          {
            "txid": "my_txid_here",
            "vout": 0
          }
        ],
        {
          "bc1qrecipientaddress...": 0.001
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "createrawtransaction",
  "params": [
    [
      {
        "txid": "my_txid_here",
        "vout": 0
      }
    ],
    {
      "bc1qrecipientaddress...": 0.001
    }
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "createrawtransaction",
  "params": [
    [
      {
        "txid": "my_txid_here",
        "vout": 0
      }
    ],
    {
      "bc1qrecipientaddress...": 0.001
    }
  ]
}

{
  "result": "0200000001abcd...00000000",
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

decoderawtransaction

POST

https://qtum-blockbook.nownodes.io/

Decodes a raw hex-encoded Bitcoin transaction and returns a JSON object with readable fields. Useful for viewing the contents of raw transactions before broadcasting.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringdecoderawtransactionrequired

paramsArray<string>required

Parameters:

hexstring (string, required) — The raw transaction hex string.

Response

200OK

Transaction decoded successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

decoderawtransaction

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "decoderawtransaction",
    "params": [
      "0200000001abcd...00000000"
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "decoderawtransaction",
      "params": [
        "0200000001abcd...00000000"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "decoderawtransaction",
  "params": [
    "0200000001abcd...00000000"
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "decoderawtransaction",
  "params": [
    "0200000001abcd...00000000"
  ]
}

{
  "result": {
    "txid": "abcd1234...",
    "hash": "abcd1234...",
    "version": 2,
    "size": 225,
    "vsize": 144,
    "locktime": 0,
    "vin": [
      {
        "txid": "input_txid",
        "vout": 0,
        "scriptSig": {
          "asm": "asm_code",
          "hex": "hex_code"
        },
        "sequence": 4294967295
      }
    ],
    "vout": [
      {
        "value": 0.001,
        "n": 0,
        "scriptPubKey": {
          "asm": "asm_output",
          "hex": "hex_output",
          "type": "witness_v0_keyhash",
          "addresses": [
            "bc1q..."
          ]
        }
      }
    ]
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

decodescript

POST

https://qtum-blockbook.nownodes.io/

Body

application/json

jsonrpcstringrequired

JSON-RPC version

idstringrequired

Request identifier

methodstringdecodescriptrequired

RPC method name

paramsArray<string>required

Parameters:

hexstring (string, required) — The script in hex format to decode.

Response

200OK

Script decoded successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

decodescript

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "decodescript",
    "params": [
      "00141d0f172a0ecb48aee1be1f2687d2963ae33f71a1"
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "decodescript",
      "params": [
        "00141d0f172a0ecb48aee1be1f2687d2963ae33f71a1"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "decodescript",
  "params": [
    "00141d0f172a0ecb48aee1be1f2687d2963ae33f71a1"
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "decodescript",
  "params": [
    "00141d0f172a0ecb48aee1be1f2687d2963ae33f71a1"
  ]
}

{
  "result": {
    "asm": "OP_0 1d0f172a0ecb48aee1be1f2687d2963ae33f71a1",
    "type": "witness_v0_keyhash",
    "reqSigs": 1,
    "addresses": [
      "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080"
    ],
    "p2sh": "3QJmV3qfvL9SuYo34YihAf3sRCW3qSinyC"
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

getrawtransaction

POST

https://qtum-blockbook.nownodes.io/

Retrieves a raw transaction by its txid. If verbose is false or omitted, the result is a raw hex string. If verbose is true, returns a JSON object with decoded transaction details.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringgetrawtransactionrequired

paramsArray<string | boolean>required

Parameters:

txid (string, required) — The transaction ID.
verbose (boolean, optional) — If true, return JSON; if false, return hex. Default: false.

Show child attributes

One of

string

boolean

Response

200OK

Transaction retrieved successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

getrawtransaction

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "getrawtransaction",
    "params": [
      "txid_here",
      true
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "getrawtransaction",
      "params": [
        "txid_here",
        true
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getrawtransaction",
  "params": [
    "txid_here",
    true
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "getrawtransaction",
  "params": [
    "txid_here",
    true
  ]
}

{
  "result": "0200000001abcd...00000000",
  "error": null,
  "id": "curltest"
}

{
  "result": {
    "txid": "abcd1234...",
    "hash": "abcd1234...",
    "version": 2,
    "size": 225,
    "vsize": 144,
    "locktime": 0,
    "vin": [
      "..."
    ],
    "vout": [
      "..."
    ],
    "hex": "0200000001abcd...00000000"
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

sendrawtransaction

POST

https://qtum-blockbook.nownodes.io/

Submits a raw transaction (hex-encoded string) to the mempool and broadcasts it to the network. Returns the transaction ID (txid) if accepted.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringsendrawtransactionrequired

paramsArray<string | number | boolean>required

Parameters:

hexstring (string, required): The raw transaction in hex format.
maxfeerate (number or boolean, optional): Reject transactions with fees higher than this (BTC/KB). Use false to disable check.

Show child attributes

One of

string

number

boolean

Response

200OK

Transaction accepted and broadcasted

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

sendrawtransaction

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "sendrawtransaction",
    "params": [
      "0200000001abcd...00000000",
      false
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "sendrawtransaction",
      "params": [
        "0200000001abcd...00000000",
        false
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "sendrawtransaction",
  "params": [
    "0200000001abcd...00000000",
    false
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "sendrawtransaction",
  "params": [
    "0200000001abcd...00000000",
    false
  ]
}

{
  "result": "abcd1234txid",
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

signrawtransactionwithkey

POST

https://qtum-blockbook.nownodes.io/

Signs inputs for a raw transaction using explicitly provided private keys, without needing access to a local wallet. Useful for offline signing or stateless transaction construction.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringsignrawtransactionwithkeyrequired

paramsArray<string | Array<string> | Array<object>>required

Parameters:

hexstring (string, required): The raw transaction hex string.
privkeys (array of strings, required): Array of WIF private keys.
prevtxs (array, optional): Array of previous output details for inputs to sign.

Show child attributes

One of

string

Array<string>

Array<object>

Show child attributes

txidstring

Transaction ID of the UTXO being spent.

voutinteger

Output index.

scriptPubKeystring

Script of the UTXO.

redeemScriptstring

(optional) Redeem script for P2SH inputs.

witnessScriptstring

(optional) Witness script for P2WSH inputs.

amountnumber

Amount in BTC of the UTXO.

Response

200OK

Transaction signed successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

signrawtransactionwithkey

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "signrawtransactionwithkey",
    "params": [
      "0200000001abcd...00000000",
      [
        "cV...yourWIFkey..."
      ],
      [
        {
          "txid": "abcd1234...",
          "vout": 0,
          "scriptPubKey": "76a914...88ac",
          "redeemScript": "0020...",
          "amount": 0.001
        }
      ]
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "signrawtransactionwithkey",
      "params": [
        "0200000001abcd...00000000",
        [
          "cV...yourWIFkey..."
        ],
        [
          {
            "txid": "abcd1234...",
            "vout": 0,
            "scriptPubKey": "76a914...88ac",
            "redeemScript": "0020...",
            "amount": 0.001
          }
        ]
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "signrawtransactionwithkey",
  "params": [
    "0200000001abcd...00000000",
    [
      "cV...yourWIFkey..."
    ],
    [
      {
        "txid": "abcd1234...",
        "vout": 0,
        "scriptPubKey": "76a914...88ac",
        "redeemScript": "0020...",
        "amount": 0.001
      }
    ]
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "signrawtransactionwithkey",
  "params": [
    "0200000001abcd...00000000",
    [
      "cV...yourWIFkey..."
    ],
    [
      {
        "txid": "abcd1234...",
        "vout": 0,
        "scriptPubKey": "76a914...88ac",
        "redeemScript": "0020...",
        "amount": 0.001
      }
    ]
  ]
}

{
  "result": {
    "hex": "0200000001abcd...00000000",
    "complete": true,
    "errors": []
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

MAINNET / Util_RPCs

signmessagewithprivkey

POST

https://qtum-blockbook.nownodes.io/

Signs a message with the given private key (in WIF format). Returns the base64-encoded signature.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringsignmessagewithprivkeyrequired

paramsArray<string>required

Parameters:

privkey (string, required): The private key in WIF format.
message (string, required): The message to sign.

Response

200OK

Message signed successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

signmessagewithprivkey

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "signmessagewithprivkey",
    "params": [
      "cV...yourWIFkey...",
      "This is my message."
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "signmessagewithprivkey",
      "params": [
        "cV...yourWIFkey...",
        "This is my message."
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "signmessagewithprivkey",
  "params": [
    "cV...yourWIFkey...",
    "This is my message."
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "signmessagewithprivkey",
  "params": [
    "cV...yourWIFkey...",
    "This is my message."
  ]
}

{
  "result": "H+JdK+U...signature==",
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

validateaddress

POST

https://qtum-blockbook.nownodes.io/

Validate a Bitcoin address and return useful information such as whether it is valid, script, or witness, and optionally if it's linked to the wallet.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringvalidateaddressrequired

paramsArray<string>required

Parameters:

address (string, required): The Bitcoin address to validate.

Response

200OK

Address validation result

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

validateaddress

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "validateaddress",
    "params": [
      "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080"
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "validateaddress",
      "params": [
        "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "validateaddress",
  "params": [
    "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080"
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "validateaddress",
  "params": [
    "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080"
  ]
}

{
  "result": {
    "isvalid": true,
    "address": "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080",
    "scriptPubKey": "0014751e76e8199196d454941c45d1b3a323f1433bd6",
    "isscript": false,
    "iswitness": true,
    "witness_version": 0,
    "witness_program": "751e76e8199196d454941c45d1b3a323f1433bd6"
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

verifymessage

POST

https://qtum-blockbook.nownodes.io/

Verify a message signature. Returns true if the signature is valid and corresponds to the provided address and message.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringverifymessagerequired

paramsArray<string>required

Parameters:

address (string, required): The Bitcoin address to verify.
signature (string, required): The base64-encoded signature.
message (string, required): The original signed message.

Response

200OK

Signature verification result

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

verifymessage

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "verifymessage",
    "params": [
      "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
      "H9zbxP...==",
      "This is a test message."
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "verifymessage",
      "params": [
        "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
        "H9zbxP...==",
        "This is a test message."
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "verifymessage",
  "params": [
    "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
    "H9zbxP...==",
    "This is a test message."
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "verifymessage",
  "params": [
    "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
    "H9zbxP...==",
    "This is a test message."
  ]
}

{
  "result": true,
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

TESTNET / Util_RPCs

signmessagewithprivkey

POST

https://qtum-blockbook.nownodes.io/

Signs a message with the given private key (in WIF format). Returns the base64-encoded signature.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringsignmessagewithprivkeyrequired

paramsArray<string>required

Parameters:

privkey (string, required): The private key in WIF format.
message (string, required): The message to sign.

Response

200OK

Message signed successfully

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

signmessagewithprivkey

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "signmessagewithprivkey",
    "params": [
      "cV...yourWIFkey...",
      "This is my message."
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "signmessagewithprivkey",
      "params": [
        "cV...yourWIFkey...",
        "This is my message."
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "signmessagewithprivkey",
  "params": [
    "cV...yourWIFkey...",
    "This is my message."
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "signmessagewithprivkey",
  "params": [
    "cV...yourWIFkey...",
    "This is my message."
  ]
}

{
  "result": "H+JdK+U...signature==",
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

validateaddress

POST

https://qtum-blockbook.nownodes.io/

Validate a Bitcoin address and return useful information such as whether it is valid, script, or witness, and optionally if it's linked to the wallet.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringvalidateaddressrequired

paramsArray<string>required

Parameters:

address (string, required): The Bitcoin address to validate.

Response

200OK

Address validation result

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

validateaddress

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "validateaddress",
    "params": [
      "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080"
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "validateaddress",
      "params": [
        "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "validateaddress",
  "params": [
    "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080"
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "validateaddress",
  "params": [
    "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080"
  ]
}

{
  "result": {
    "isvalid": true,
    "address": "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080",
    "scriptPubKey": "0014751e76e8199196d454941c45d1b3a323f1433bd6",
    "isscript": false,
    "iswitness": true,
    "witness_version": 0,
    "witness_program": "751e76e8199196d454941c45d1b3a323f1433bd6"
  },
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

verifymessage

POST

https://qtum-blockbook.nownodes.io/

Verify a message signature. Returns true if the signature is valid and corresponds to the provided address and message.

Body

application/json

jsonrpcstringrequired

idstringrequired

methodstringverifymessagerequired

paramsArray<string>required

Parameters:

address (string, required): The Bitcoin address to verify.
signature (string, required): The base64-encoded signature.
message (string, required): The original signed message.

Response

200OK

Signature verification result

401Unauthorized

Unauthorized

500Internal Server Error

Internal Server Error

Authorization

api-keyAuthapiKey in header

verifymessage

curl -X POST 'https://qtum-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "1.0",
    "id": "curltest",
    "method": "verifymessage",
    "params": [
      "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
      "H9zbxP...==",
      "This is a test message."
    ]
  }'

const response = await fetch('https://qtum-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "1.0",
      "id": "curltest",
      "method": "verifymessage",
      "params": [
        "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
        "H9zbxP...==",
        "This is a test message."
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "verifymessage",
  "params": [
    "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
    "H9zbxP...==",
    "This is a test message."
  ]
}

response = requests.post('https://qtum-blockbook.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "1.0",
  "id": "curltest",
  "method": "verifymessage",
  "params": [
    "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
    "H9zbxP...==",
    "This is a test message."
  ]
}

{
  "result": true,
  "error": null,
  "id": "curltest"
}

"Unknown API_key"

"Service is unavailable"

Documentation

Authentication

MAINNET / Blockbook

BlockBook

Response

Authorization

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Body

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

BlockBook (legacy)

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response