Blockbook API

v2.0.0-draft

Base URL

https://dashbook.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

NOWNodes API key passed in the api-key header.

API Key: api-key in header

Blockbook 0.6.0

BlockBook

BlockBook operations.

Get Blockbook and backend status.

GET

https://dashbook.nownodes.io/api/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns Blockbook sync state and connected backend metadata.

Load estimate: Low; constant-size status metadata.

Response

200OK

Current Blockbook and backend status.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

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

Get Blockbook and backend status.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/status')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/status";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/status')
request = Net::HTTP::Get.new(uri)

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

{
  "blockbook": {
    "coin": "Dash",
    "network": "DASH",
    "host": "eed20d24eff9",
    "version": "0.6.0",
    "gitCommit": "89963a3",
    "buildTime": "2026-08-06T06:44:18+0000",
    "syncMode": true,
    "initialSync": false,
    "inSync": true,
    "bestHeight": 2517737,
    "lastBlockTime": "2026-08-07T06:38:27.9081605Z",
    "inSyncMempool": true,
    "lastMempoolTime": "2026-08-07T06:38:49.350151555Z",
    "mempoolSize": 3,
    "decimals": 8,
    "dbSize": 58790162555,
    "hasFiatRates": true,
    "hasTokenFiatRates": true,
    "currentFiatRatesTime": "2026-08-06T04:30:02.891437085Z",
    "historicalFiatRatesTime": "2026-08-06T00:00:00Z",
    "historicalTokenFiatRatesTime": "string",
    "about": "Blockbook - blockchain indexer for Trezor Suite https://trezor.io/trezor-suite. Do not use for any other purpose."
  },
  "backend": {
    "chain": "main",
    "blocks": 2517737,
    "headers": 2517737,
    "bestBlockHash": "0000000000000009602513c0d952e9a1c53de4e66d813dd4a0492015f3099925",
    "difficulty": "116069714.130871",
    "sizeOnDisk": 49453640236,
    "version": "230107",
    "subversion": "/Dash Core:23.1.7(dashcore)/",
    "protocolVersion": "70240",
    "timeOffset": 0,
    "warnings": "string",
    "error": "string",
    "consensus_version": "string"
  }
}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

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

Get status from the API index handler.

GET

https://dashbook.nownodes.io/api

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Get status from the API index handler.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/')
request = Net::HTTP::Get.new(uri)

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

{
  "blockbook": {
    "coin": "Dash",
    "network": "DASH",
    "host": "eed20d24eff9",
    "version": "0.6.0",
    "gitCommit": "89963a3",
    "buildTime": "2026-08-06T06:44:18+0000",
    "syncMode": true,
    "initialSync": false,
    "inSync": true,
    "bestHeight": 2517737,
    "lastBlockTime": "2026-08-07T06:38:27.9081605Z",
    "inSyncMempool": true,
    "lastMempoolTime": "2026-08-07T06:38:49.350151555Z",
    "mempoolSize": 3,
    "decimals": 8,
    "dbSize": 58790162555,
    "hasFiatRates": true,
    "hasTokenFiatRates": true,
    "currentFiatRatesTime": "2026-08-06T04:30:02.891437085Z",
    "historicalFiatRatesTime": "2026-08-06T00:00:00Z",
    "historicalTokenFiatRatesTime": "string",
    "about": "Blockbook - blockchain indexer for Trezor Suite https://trezor.io/trezor-suite. Do not use for any other purpose."
  },
  "backend": {
    "chain": "main",
    "blocks": 2517737,
    "headers": 2517737,
    "bestBlockHash": "0000000000000009602513c0d952e9a1c53de4e66d813dd4a0492015f3099925",
    "difficulty": "116069714.130871",
    "sizeOnDisk": 49453640236,
    "version": "230107",
    "subversion": "/Dash Core:23.1.7(dashcore)/",
    "protocolVersion": "70240",
    "timeOffset": 0,
    "warnings": "string",
    "error": "string",
    "consensus_version": "string"
  }
}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Internal server error"
}

Get a block hash by height.

GET

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

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Get a block hash by height.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/block-index/{height}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v2/block-index/{height}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/block-index/{height}')
request = Net::HTTP::Get.new(uri)

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

{
  "blockHash": "0000000000000002f4e4070599fbc5dd6d0ed985f5e40a76526f977d7455f3c6"
}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Internal server error"
}

Get a block by height or hash.

GET

https://dashbook.nownodes.io/api/v2/block/{blockId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Get a block by height or hash.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/block/{blockId}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v2/block/{blockId}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/block/{blockId}')
request = Net::HTTP::Get.new(uri)

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

{
  "page": 1,
  "totalPages": 1,
  "itemsOnPage": 1000,
  "hash": "0000000000000002f4e4070599fbc5dd6d0ed985f5e40a76526f977d7455f3c6",
  "previousBlockHash": "000000000000000c8cc1fe7ee5987235e5f635aa47f3d77726a1af88d54caa36",
  "nextBlockHash": "000000000000001c2c1b881229941713741fca10c613eb43f970ec7122242da1",
  "height": 2517735,
  "confirmations": 3,
  "size": 3778,
  "time": 1786084083,
  "version": 536870912,
  "merkleRoot": "cf44561cd8dca4916db04ac2da997625ad942e489798a4c54794972eba492bfd",
  "nonce": "3442612398",
  "bits": "192580f4",
  "difficulty": "114519343.678183",
  "tx": [
    "2b9fc57aaa8d01975631a703b0fc3f11d70671953fc769533b8078a04d029bf9"
  ],
  "txCount": 6,
  "txs": [],
  "addressAliases": {}
}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Block not found"
}

Get raw block hex.

GET

https://dashbook.nownodes.io/api/v2/rawblock/{blockId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Get raw block hex.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/rawblock/{blockId}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v2/rawblock/{blockId}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/rawblock/{blockId}')
request = Net::HTTP::Get.new(uri)

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

{
  "hex": "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"
}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Block not found"
}

Get compact block filters.

GET

https://dashbook.nownodes.io/api/v2/block-filters

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

Compact block filters are not currently enabled on the NOWNodes Dash endpoint. Requests succeed and return the requested heights with their block hashes, but each filter value comes back empty. Send scriptType empty, as no script type is configured.

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

Parameters

scriptTypestringrequiredquery

Script type used for block filters. No script type is configured on the NOWNodes Dash endpoint, so send this parameter empty.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Get compact block filters.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/block-filters/')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v2/block-filters/";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/block-filters/')
request = Net::HTTP::Get.new(uri)

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

{
  "P": 0,
  "M": 1,
  "zeroedKey": false,
  "blockFilters": {
    "2517735": {
      "blockHash": "0000000000000002f4e4070599fbc5dd6d0ed985f5e40a76526f977d7455f3c6",
      "filter": "0286f0..."
    }
  }
}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Invalid scriptType taproot. Use "
}

Get a normalized transaction.

GET

https://dashbook.nownodes.io/api/v2/tx/{txid}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Get a normalized transaction.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/tx/{txid}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v2/tx/{txid}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/tx/{txid}')
request = Net::HTTP::Get.new(uri)

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

{
  "txid": "65f4d6e8e6a87a0c67a17a908731dd23c7ae9a38229cdcf5fb7b67f0aab7f665",
  "version": 1,
  "vin": [
    {
      "txid": "e66ff9b567bb8176ed65f5eea2c83801d09bbefba57336cb47311acc6615b19e",
      "vout": 21,
      "sequence": 4294967295,
      "n": 0,
      "addresses": [
        "XdoaXjsFLnp2mcGVVWQR6PEEQPKKhk4aEV"
      ],
      "isAddress": true,
      "value": "14495349",
      "hex": "4730440220203a653d6295af1c06bcb52574acc96fd30ea1ffa9637ece7f269f9325fb0e50022053c3e21378b4924a80113088b13a5f775cb0bc74e8e36090675004d74797eee0012102ce387685d901544a9f0f0f3a492152196f9c1b086646343e1d80938ada3a7d67"
    }
  ],
  "vout": [
    {
      "value": "14495123",
      "n": 0,
      "spent": true,
      "spentTxId": "b98944658124a1b92ef6563fba4fd35022d8c0c0f28cdae190adf15f243a8b9f",
      "spentHeight": 2516775,
      "hex": "76a91496f349dc5ecacc35043c317053cdc8a15d92fbb588ac",
      "addresses": [
        "XpSze1a7RSuVGr3ASeT6h3YwYm9SDMYTsh"
      ],
      "isAddress": true
    }
  ],
  "blockHash": "00000000000000043e7e373acf89a09c74e7b9e736468cbc47f6ef05bd5b4e5a",
  "blockHeight": 2516629,
  "confirmations": 2035,
  "blockTime": 1785910052,
  "size": 191,
  "value": "14495123",
  "valueIn": "14495349",
  "fees": "226",
  "hex": "01000000019eb11566cc1a3147cb3673a5fbbe9bd00138c8a2eef565ed7681bb67b5f96fe6150000006a4730440220203a653d6295af1c06bcb52574acc96fd30ea1ffa9637ece7f269f9325fb0e50022053c3e21378b4924a80113088b13a5f775cb0bc74e8e36090675004d74797eee0012102ce387685d901544a9f0f0f3a492152196f9c1b086646343e1d80938ada3a7d67ffffffff01932ddd00000000001976a91496f349dc5ecacc35043c317053cdc8a15d92fbb588ac00000000"
}

{
  "txid": "75f16bdcb8dc027482ddc24a41f13aba42c5259080c4630579f7525104fe363b",
  "version": 2,
  "vin": [
    {
      "txid": "201cf922804f807b369facaf2f4463d169cd952061ca0820211d05ff6decb778",
      "vout": 1,
      "sequence": 4294967295,
      "n": 0,
      "addresses": [
        "Xf7fJsY8pYpZQ3bVWNRo7q3nGq6vCA5WkS"
      ],
      "isAddress": true,
      "value": "10000100",
      "hex": "473044022016ee89d7f5d0a02b7daa301cddecfc534ffa682f0b8fbee6946420904877fbc00220719d64818efb1c16660aee8d3e228ad72e95a4de09bbc2e5894280c972039f4381210212333d7d7801367c3da94e72dcb26be569b18977faa30bbfee8cae59d0f3882f"
    },
    {
      "txid": "3180b4182018090e2d080a908624dbb8deb59b78e27b3c56d363ddc861c42712",
      "sequence": 4294967295,
      "n": 1,
      "addresses": [
        "XaouvQfMpAEDRd5e88sntRsyBXQMMeP9JE"
      ],
      "isAddress": true,
      "value": "10000100",
      "hex": "463043021f19615c069daad535e8ac5f626c9cfdaf3183401f7b0d0a960b5fcb7f8c8d020220447fe78f379bdc6462d06bbc0203cd2dc19ddedec35bb38b73afafed4db6fc5f812103ea62314c4388804d17531d62cc0a9d6b2faa32260357a1899ddca9802681866f"
    },
    {
      "txid": "3180b4182018090e2d080a908624dbb8deb59b78e27b3c56d363ddc861c42712",
      "vout": 3,
      "sequence": 4294967295,
      "n": 2,
      "addresses": [
        "XuJM6KWv28nUcMX1cXQvzJJ2khJ34Yiktr"
      ],
      "isAddress": true,
      "value": "10000100",
      "hex": "47304402203df49fca70b9fd1be0c445d3d694be65e2074421db1206b25914bbaa402d28c002200a2d0c3604b891c877c562343147ba9186b5086456d87814053d9d542edcc0ad8121034998b35d07fe5d2c09d3a41fb7d0a9dedbcf7c2dfad909ad987f847d89f2848f"
    },
    {
      "txid": "45b6e93f78006767f748c651fc3fa0be9c0690c7dc6d4b8add1adebe7c5b8fd9",
      "vout": 1,
      "sequence": 4294967295,
      "n": 3,
      "addresses": [
        "XeQWERUPUeu5UKVv24BTRssmbtZWcKcxyb"
      ],
      "isAddress": true,
      "value": "10000100",
      "hex": "47304402205c6880a2783676b94c41fa75aed7544ec04ac0e3727df220561b0ff0fb657bac022019eca9292bea305df0dc69692996e28cbcfa25d19f1dc0f20ec4f4b53d063ee8812102f43d9a817d98cf5a16276f455f3ba2a989e69f958e1f41082332bedf8a33361f"
    },
    {
      "txid": "4c62c5416cb52e6e44fef2c0d8dc202f66a299a610914dfbe1fa87adb69784dc",
      "vout": 1,
      "sequence": 4294967295,
      "n": 4,
      "addresses": [
        "XheK8fwXnVVt4Wb8ZgPaJqDRHX868sYpFy"
      ],
      "isAddress": true,
      "value": "10000100",
      "hex": "473044022011e6f101306f21405595bb67c90d0ff71552e43b961f7a088daa47d84cc2e4d902206fe56784bb74ccaa968df8da3a78701731cb60f4cd50e3ef9b9e508aa4473eef8121022b255b609dabbfa46ed36d91c16b920689bb9849a6cdd3f7cc666d01cceb653e"
    },
    {
      "txid": "52baea015cc4cf40c3f140a0f8fd1007812bfd3229a4a28c9db86d7b4aaef59b",
      "vout": 3,
      "sequence": 4294967295,
      "n": 5,
      "addresses": [
        "XmdTvHFwUdF6SSFKArv3qFnke9TLy3RnVf"
      ],
      "isAddress": true,
      "value": "10000100",
      "hex": "4730440220351d1a04e556229dd920166fa3b98ae3821d64cfcb33757b8aec1e59ad90843102200a1065a0c96dc98e47bee61ee664d57de67371c795ab3b2abba61ad5f6361ebb812103a99c0bcd107ae13ba36a487cb18d7101e2cd8012b43b086f9aafabf9ee93a32d"
    },
    {
      "txid": "645245ffdb86631acd32310c38a28630d6922ac901688f3c3085457875cb0c41",
      "sequence": 4294967295,
      "n": 6,
      "addresses": [
        "Xc39ZMQt3prtm7VKHeEyEKM4JVG6dD3Job"
      ],
      "isAddress": true,
      "value": "10000100",
      "hex": "473044022053a1f19c5372affc652686b4e3d5c740b47a08a4381190bffbd37dba985381d0022048a060f6dfcb94e52c907e9a277a625450e976a4e0ec67ce352efcc5829548218121021100c24016542aafbf0906d438155b06bef1bb936b212770b4ebe9e300d51b41"
    },
    {
      "txid": "645245ffdb86631acd32310c38a28630d6922ac901688f3c3085457875cb0c41",
      "vout": 6,
      "sequence": 4294967295,
      "n": 7,
      "addresses": [
        "XmkzWSak1yuhcywmZzrRaZy5iQuZVCmUXT"
      ],
      "isAddress": true,
      "value": "10000100",
      "hex": "47304402202c4e76e0059fdba908aff727a0d6987f5ae1e6fd07ccfbab544fababf82db54802206dd8670e7f7733d2bcb83cd4d11afe8bc231fd9f6a8c6615cbd5a0c06edc3ead8121033af6b0f1497775c088f6bdb5ffc55e52e4bc800b2e92f5ca059827dd3a4acc7b"
    },
    {
      "txid": "b04e3c30b5d6d5ac774cc99dbc7762b1fda0999d84cb6d7c5d3525b824c1ee24",
      "vout": 1,
      "sequence": 4294967295,
      "n": 8,
      "addresses": [
        "XpVf986CbDdtF17oiDTDAVn299fChX2hjT"
      ],
      "isAddress": true,
      "value": "10000100",
      "hex": "4730440220439641dde76cf8d6157436a8317e5bea533dc426d02c0b5cfe65e1d1e991d2f70220171fe7437c29f2ee7c77a49baa34b87f187b580f976f0768a9d1fe8813a46c02812103fa854add3b0fa621205a673af78cb77044d8daa21b4576a3c5112d7f1ed67d53"
    },
    {
      "txid": "cee4dbfee694fc37bf98273df7fb0369751e9942b5dc33415b8fad6eaa3ced15",
      "vout": 1,
      "sequence": 4294967295,
      "n": 9,
      "addresses": [
        "XdZZgMgN1uAcKYCPWnA2FBmU1ApNqVVKx8"
      ],
      "isAddress": true,
      "value": "10000100",
      "hex": "47304402206cd202ba0ff4edd0f87c72de4b7fce306a14ff584dce01b9b18d946ff66a73b90220347882f301ad45566affe4ae7a99cc71f56472bab8d468e57c93cda3e1f2368f8121029ff94a52c0627fa7bc130c30641658d2b41f6b2de6e341b3a98c6a2706dc75a5"
    }
  ],
  "vout": [
    {
      "value": "10000100",
      "n": 0,
      "hex": "76a914402d47537b0546a0ddec56f8a245e177db4a956e88ac",
      "addresses": [
        "XgYBKYWdx5fEpuLG6Srb1S83HBU6oxLr5h"
      ],
      "isAddress": true
    },
    {
      "value": "10000100",
      "n": 1,
      "hex": "76a9144917bf6df4eb5310b8e5146f4f067f0284e6ebe788ac",
      "addresses": [
        "XhMKcHG8Y2suBnvrgcQCpwRBD5XRXf5Jot"
      ],
      "isAddress": true
    },
    {
      "value": "10000100",
      "n": 2,
      "hex": "76a9145724a17ac3cf14c1a37a1111bd933ac16e1e4fe488ac",
      "addresses": [
        "XidcW6Q61CJqZcBNr4RyfhraGcwbFZLW4W"
      ],
      "isAddress": true
    },
    {
      "value": "10000100",
      "n": 3,
      "hex": "76a9147ee757879f2a322d1a120f442b9b5bdff9fc12bf88ac",
      "addresses": [
        "XnFr7Lno5dxhvTCL8bfKcVXyMMA2tseHJi"
      ],
      "isAddress": true
    },
    {
      "value": "10000100",
      "n": 4,
      "hex": "76a9148b25873f4475791bfdda76d63471dec7d55e13d888ac",
      "addresses": [
        "XoNaiRvXSYNo3tpDPQCiEbgMjpRhHu5qGv"
      ],
      "isAddress": true
    },
    {
      "value": "10000100",
      "n": 5,
      "hex": "76a914b539bc3ab8908cce458b0077375c85d78f3d0d4688ac",
      "addresses": [
        "XsD5JVUQp7tV95QS1mz5PtZrRaQuPV1NFr"
      ],
      "isAddress": true
    },
    {
      "value": "10000100",
      "n": 6,
      "hex": "76a914bb78c6b21318701a2a5b85f77abf58a70eb971b088ac",
      "addresses": [
        "Xsn6soMmeW6WNTiTx1KQSbmBFou66EmNX5"
      ],
      "isAddress": true
    },
    {
      "value": "10000100",
      "n": 7,
      "hex": "76a914be38c5342829254e88b9d5c664d207a586c3bf9c88ac",
      "addresses": [
        "Xt2eEAyHDLPaznzZByaiPjj42e1kuReqZu"
      ],
      "isAddress": true
    },
    {
      "value": "10000100",
      "n": 8,
      "hex": "76a914ccb7d18788f60291d214ace0536b5ccd7936114388ac",
      "addresses": [
        "XuMHtKRFmWmd8NeVTaDQ1geGzx5c847jvw"
      ],
      "isAddress": true
    },
    {
      "value": "10000100",
      "n": 9,
      "hex": "76a914fba3ed429307197e683f0ac6e5a2b584908e252588ac",
      "addresses": [
        "XydPpEfd6hkUga2WQanvD5SYy5SmyuGDkY"
      ],
      "isAddress": true
    }
  ],
  "blockHash": "0000000000000002f4e4070599fbc5dd6d0ed985f5e40a76526f977d7455f3c6",
  "blockHeight": 2517737,
  "confirmations": 1,
  "blockTime": 1786084697,
  "size": 1819,
  "value": "100001000",
  "valueIn": "100001000",
  "fees": "0",
  "hex": "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"
}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Transaction not found"
}

Get blockchain-specific transaction JSON.

GET

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

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Get blockchain-specific transaction JSON.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/tx-specific/{txid}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v2/tx-specific/{txid}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/tx-specific/{txid}')
request = Net::HTTP::Get.new(uri)

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

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Transaction '65f4d6e8e6a87a0c67a17a908731dd23c7ae9a38229cdcf5fb7b67f0aab7f665' not found"
}

Get raw transaction hex (Ethereum-type networks only).

GET

https://dashbook.nownodes.io/api/rawtx/{txid}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Unversioned public endpoint exposed by Blockbook for raw transaction data.

Available on Ethereum-type networks only. It is not supported on Dash, where requests to this endpoint return an error.

To get the raw transaction hex on Dash, use /api/v2/tx-specific/{txid} and read its hex field, or call the getrawtransaction JSON-RPC method.

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

Parameters

txidstringrequiredpath

Transaction id/hash.

Response

200OK

Raw transaction hex as a JSON string. Not returned on Dash; see the endpoint description.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Get raw transaction hex (Ethereum-type networks only).

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/rawtx/{txid}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/rawtx/{txid}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/rawtx/{txid}')
request = Net::HTTP::Get.new(uri)

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

"string"

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Transaction not found"
}

Broadcast a raw transaction using the path.

GET

https://dashbook.nownodes.io/api/v2/sendtx/{hex}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Broadcast a raw transaction using the path.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/sendtx/{hex}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v2/sendtx/{hex}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/sendtx/{hex}')
request = Net::HTTP::Get.new(uri)

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

{
  "result": "65f4d6e8e6a87a0c67a17a908731dd23c7ae9a38229cdcf5fb7b67f0aab7f665"
}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Missing tx blob"
}

Broadcast a raw transaction using the request body.

POST

https://dashbook.nownodes.io/api/v2/sendtx

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

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.

Alternative schema variant for this parameter or payload.

string

Response

200OK

Broadcast result.

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

default

Public API error.

Broadcast a raw transaction using the request body.

curl -X POST 'https://dashbook.nownodes.io/api/v2/sendtx/' \
  -H 'Content-Type: text/plain' \
  -d '"0200000001d6aa4e52f5217cad621292450157e0e583db367597ce2beb79f2168e1d7a020b"'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/sendtx/')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'text/plain'
request.body = '"0200000001d6aa4e52f5217cad621292450157e0e583db367597ce2beb79f2168e1d7a020b"'

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

import requests

payload = "0200000001d6aa4e52f5217cad621292450157e0e583db367597ce2beb79f2168e1d7a020b"

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v2/sendtx/";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

payload = "0200000001d6aa4e52f5217cad621292450157e0e583db367597ce2beb79f2168e1d7a020b"

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/sendtx/')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'text/plain'
request.body = '"0200000001d6aa4e52f5217cad621292450157e0e583db367597ce2beb79f2168e1d7a020b"'

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

Request Body

0200000001d6aa4e52f5217cad621292450157e0e583db367597ce2beb79f2168e1d7a020b

{
  "result": "65f4d6e8e6a87a0c67a17a908731dd23c7ae9a38229cdcf5fb7b67f0aab7f665"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "result": "65f4d6e8e6a87a0c67a17a908731dd23c7ae9a38229cdcf5fb7b67f0aab7f665"
}

{
  "error": "-22: TX decode failed. Make sure the tx has at least one input."
}

Get address/account details.

GET

https://dashbook.nownodes.io/api/v2/address/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

Dash address, XPUB, or descriptor value accepted by Blockbook.

pageinteger<int32>>= 11query

Page number of the returned transaction list. Pagination starts from 1.

pageSizeinteger<int32>[1, 1000]1000query

Maximum number of transactions returned on one page.

frominteger<int64>>= 0query

Start block height filter for transactions, inclusive.

tointeger<int64>>= 0query

End block height filter for transactions, inclusive.

detailsstringbasictokenstokenBalancestxidstxslighttxstxidsquery

Controls how much transaction or token detail is included in the response. Supported values: basic, tokens, tokenBalances, txids, txslight, txs.

tokensstringusednonzeroderivedquery

Token list mode for the address response. Use used to include tokens used by the address, nonzero to include only non-zero balances, or derived to include derived token information when supported.

secondarystringquery

Secondary currency code. When set, balance and transaction fields are additionally returned in this currency.

contractstringquery

Smart-contract address used to filter token-related address data.

filterstring | integerquery

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

protocolsArray<string>query

Optional protocol enrichments. Available on Ethereum-type networks only; on Dash any value returns an error, so the parameter should be omitted.

Response

200OK

Address/account details.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Get address/account details.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/address/{address}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v2/address/{address}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/address/{address}')
request = Net::HTTP::Get.new(uri)

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

{
  "page": 1,
  "totalPages": 450,
  "itemsOnPage": 2,
  "address": "XdoaXjsFLnp2mcGVVWQR6PEEQPKKhk4aEV",
  "balance": "1010",
  "totalReceived": "6011672543",
  "totalSent": "6011671533",
  "unconfirmedBalance": "0",
  "unconfirmedTxs": 0,
  "txs": 900,
  "txids": [
    "5281b73a542c08435fc9bc0b2893505fd9ab44c937872f5b81895778b7bd36a8",
    "6e1f428557cf461ddfd797515402826ceb794a387644faaaacda20cfc2b2930c"
  ]
}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Invalid address "
}

Get XPUB or descriptor account details.

GET

https://dashbook.nownodes.io/api/v2/xpub/{xpub}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns balances and transactions of an XPUB or output descriptor for Bitcoin-type coins. Transactions are sorted by block height with newest blocks first. URL-encode descriptors before placing them after /xpub/.

Blockbook expects XPUBs at level 3 of the derivation path, for example m/purpose'/coin_type'/account'. It derives the remaining change/address_index path. The BIP scheme is inferred from the XPUB prefix; unknown prefixes default to BIP44.

Supported descriptors are pkh(xpub), sh(wpkh(xpub)), wpkh(xpub), and tr(xpub). Descriptors can include origin paths and change selectors such as <0;1> or {0,1}; when change is omitted, Blockbook defaults to <0;1>.

Note: usedTokens always reports the total number of used addresses for the XPUB, regardless of the tokens query filter.

Load estimate: High for broad accounts; grows with derived addresses, gap, used address count, pageSize, transaction history, token rows, and protocol enrichment.

Parameters

xpubstringrequiredpath

Extended public key or output descriptor to query in Blockbook.

pageinteger<int32>>= 11query

Page number of the returned transaction list. Pagination starts from 1.

pageSizeinteger<int32>[1, 1000]1000query

Maximum number of transactions returned on one page.

frominteger<int64>>= 0query

Start block height filter for transactions, inclusive.

tointeger<int64>>= 0query

End block height filter for transactions, inclusive.

detailsstringbasictokenstokenBalancestxidstxslighttxstxidsquery

Controls how much transaction or token detail is included in the response. Supported values: basic, tokens, tokenBalances, txids, txslight, txs.

tokensstringnonzerousedderivednonzeroquery

Controls which XPUB-derived address rows are included.

filterstring | integerquery

Filter by input/output side or numeric id.

contractstringquery

Contract address filter.

protocolsArray<string>query

Protocol enrichments.

secondarystringquery

Secondary currency code.

gapinteger[0, 10000]query

XPUB/address derivation gap limit.

Response

200OK

XPUB/descriptor account details.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Get XPUB or descriptor account details.

curl -X GET 'https://dashbook.nownodes.io/api/v2/xpub/{xpub}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/xpub/{xpub}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://dashbook.nownodes.io/api/v2/xpub/{xpub}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v2/xpub/{xpub}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://dashbook.nownodes.io/api/v2/xpub/{xpub}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/xpub/{xpub}')
request = Net::HTTP::Get.new(uri)

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

{
  "page": 1,
  "totalPages": 1,
  "itemsOnPage": 1000,
  "address": "drkpRsmwKURS9g8uDqs1tGTJwh16JHZ27Q49iCXHQ2rD7fFVix4LRp47wHSYAKiA36eutcFj9Uj8U5CEukoHAYozphT85LewVG1iz4iRrqJvnd3",
  "balance": "0",
  "totalReceived": "0",
  "totalSent": "0",
  "unconfirmedBalance": "0",
  "unconfirmedTxs": 0,
  "unconfirmedSending": "0",
  "unconfirmedReceiving": "0",
  "txs": 0,
  "addrTxCount": 24,
  "nonTokenTxs": 0,
  "internalTxs": 0,
  "transactions": [],
  "txids": [
    "13549d9bbea98d362a54fb5d96935db3d4d9a831b1e13163720386f7bc1ee7cd"
  ],
  "nonce": "0",
  "usedTokens": 5,
  "tokens": [
    {
      "type": "XPUBAddress",
      "standard": "XPUBAddress",
      "path": "m/44'/0'/0'/0/0",
      "transfers": 3,
      "decimals": 8,
      "balance": "90000000",
      "totalReceived": "2903986975",
      "totalSent": "2803986975"
    }
  ],
  "secondaryValue": 21195.47633568,
  "tokensBaseValue": 0,
  "tokensSecondaryValue": 0,
  "totalBaseValue": 0,
  "totalSecondaryValue": 21195.47633568,
  "contractInfo": {
    "type": "ERC20",
    "standard": "ERC20",
    "contract": "0x4E15361FD6b4BB609Fa63C81A2be19d873717870",
    "name": "Token",
    "symbol": "TKN",
    "decimals": 18,
    "createdInBlock": 0,
    "destructedInBlock": 0,
    "rates": {
      "baseRate": 0.000523,
      "currency": "usd",
      "secondaryRate": 1.24
    },
    "protocols": {
      "erc4626": {
        "asset": {
          "contract": "0x4E15361FD6b4BB609Fa63C81A2be19d873717870",
          "name": "WETH",
          "symbol": "WETH",
          "decimals": 18
        },
        "share": {
          "contract": "0x4E15361FD6b4BB609Fa63C81A2be19d873717870",
          "name": "vToken",
          "symbol": "vToken",
          "decimals": 18
        },
        "totalAssets": "123456789",
        "convertToAssets1Share": "1000000000000000000",
        "convertToShares1Asset": "1000000000000000000",
        "previewDeposit1Asset": "999999999999999999",
        "previewRedeem1Share": "1000000000000000000",
        "error": "string"
      }
    },
    "blockHeight": 12345678
  },
  "addressAliases": {},
  "stakingPools": [],
  "chainExtraData": {
    "payloadType": "tron"
  }
}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Missing xpub"
}

Get UTXOs for an address, XPUB, or descriptor.

GET

https://dashbook.nownodes.io/api/v2/utxo/{descriptor}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns unspent outputs for an address, XPUB, or descriptor on Bitcoin-type coins. By default both confirmed and unconfirmed UTXOs are returned; confirmed=true filters out unconfirmed entries. Results are sorted by block height with newest entries first.

Unconfirmed UTXOs omit height, have confirmations set to 0, and can include lockTime. XPUB and descriptor UTXOs also include address and derivation path when available. Coinbase UTXOs include coinbase=true only up to the coinbase confirmation limit, currently 100 blocks.

Load estimate: Variable; address lookups are usually medium, while XPUB/descriptor lookups grow with gap, derived addresses, and UTXO count.

Parameters

descriptorstringrequiredpath

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

confirmedbooleanquery

When true, return only confirmed UTXOs.

gapinteger[0, 10000]query

XPUB/address derivation gap limit.

Response

200OK

UTXO list.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Get UTXOs for an address, XPUB, or descriptor.

curl -X GET 'https://dashbook.nownodes.io/api/v2/utxo/{descriptor}'

const response = await fetch('https://dashbook.nownodes.io/api/v2/utxo/{descriptor}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/utxo/{descriptor}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://dashbook.nownodes.io/api/v2/utxo/{descriptor}')
data = response.json()

const response = await fetch('https://dashbook.nownodes.io/api/v2/utxo/{descriptor}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v2/utxo/{descriptor}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://dashbook.nownodes.io/api/v2/utxo/{descriptor}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://dashbook.nownodes.io/api/v2/utxo/{descriptor}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/utxo/{descriptor}')
request = Net::HTTP::Get.new(uri)

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

[
  {
    "txid": "398ef07a84c5267aae3bd0d0d7535fda9b4c67efe6981b5635bce74ae3a813d6",
    "vout": 0,
    "value": "1010",
    "height": 2515533,
    "confirmations": 2205,
    "address": "string",
    "path": "string",
    "lockTime": 0,
    "coinbase": true
  }
]

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Invalid address 'notanaddress', checksum mismatch"
}

Get account balance history.

GET

https://dashbook.nownodes.io/api/v2/balancehistory/{descriptor}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Get account balance history.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/balancehistory/{descriptor}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v2/balancehistory/{descriptor}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/balancehistory/{descriptor}')
request = Net::HTTP::Get.new(uri)

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

[
  {
    "time": 1785898800,
    "txs": 5,
    "received": "627791049",
    "sent": "0",
    "sentToSelf": "100000",
    "rates": {
      "usd": 64345.492,
      "eur": 55589.92
    }
  },
  {
    "time": 1785902400,
    "txs": 1,
    "received": "0",
    "sent": "627791049",
    "sentToSelf": "0",
    "rates": {
      "usd": 64107.65,
      "eur": 55589.92
    }
  }
]

[
  {
    "time": 1785898800,
    "txs": 5,
    "received": "627791049",
    "sent": "0",
    "sentToSelf": "0",
    "rates": {
      "usd": 64345.492
    }
  },
  {
    "time": 1785902400,
    "txs": 1,
    "received": "0",
    "sent": "627791049",
    "sentToSelf": "0",
    "rates": {
      "usd": 64107.65
    }
  }
]

[
  {
    "time": 1786060800,
    "txs": 1,
    "received": "0",
    "sent": "14010689",
    "sentToSelf": "0"
  }
]

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Missing address"
}

Get contract metadata (Ethereum-type networks only).

GET

https://dashbook.nownodes.io/api/v2/contract/{contract}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

Available on Ethereum-type networks only. Dash has no contract or token layer, so requests to this endpoint return an error.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Get contract metadata (Ethereum-type networks only).

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/contract/{contract}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v2/contract/{contract}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/contract/{contract}')
request = Net::HTTP::Get.new(uri)

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

{
  "type": "ERC20",
  "standard": "ERC20",
  "contract": "0x0000000000000000000000000000000000000001",
  "name": "Vault Share",
  "symbol": "vETH",
  "decimals": 18,
  "createdInBlock": 0,
  "destructedInBlock": 0,
  "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",
      "error": "string"
    }
  },
  "blockHeight": 12345678
}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Contract not found"
}

Estimate a fee target.

GET

https://dashbook.nownodes.io/api/v2/estimatefee/{blocks}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Estimate a fee target.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/estimatefee/{blocks}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v2/estimatefee/{blocks}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/estimatefee/{blocks}')
request = Net::HTTP::Get.new(uri)

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

{
  "result": "0.00001"
}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Parameter 'number of blocks' is not a number"
}

Get fee statistics for a block.

GET

https://dashbook.nownodes.io/api/v2/feestats/{blockId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Get fee statistics for a block.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/feestats/{blockId}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v2/feestats/{blockId}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/feestats/{blockId}')
request = Net::HTTP::Get.new(uri)

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

{
  "txCount": 5,
  "totalFeesSat": "20002",
  "averageFeePerKb": 23814,
  "decilesFeePerKb": [
    0,
    0,
    0,
    0,
    0,
    1000,
    1000,
    1000,
    117071,
    117071,
    117071
  ]
}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Block not found"
}

Get current or historical fiat rates.

GET

https://dashbook.nownodes.io/api/v2/tickers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Not available on this endpoint: the request returns HTTP 400 with {"error":"No tickers found!"}.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error. Returned when no fiat rate is available for the requested currency or timestamp.

Get current or historical fiat rates.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/tickers/')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v2/tickers/";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/tickers/')
request = Net::HTTP::Get.new(uri)

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

{
  "ts": 1785902400,
  "rates": {
    "eur": 55589.92,
    "usd": 64107.65
  }
}

{
  "ts": 1785902400,
  "rates": {
    "usd": 64107.65
  }
}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Parameter 'timestamp' is not a valid Unix timestamp."
}

Get fiat rates for multiple timestamps.

GET

https://dashbook.nownodes.io/api/v2/multi-tickers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Not available on this endpoint: the request returns HTTP 400 with {"error":"No tickers found"}.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Get fiat rates for multiple timestamps.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/multi-tickers/')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v2/multi-tickers/";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/multi-tickers/')
request = Net::HTTP::Get.new(uri)

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

[
  {
    "ts": 1785902400,
    "rates": {
      "usd": 64107.65
    },
    "error": "Parameter \"timestamp\" is not a valid Unix timestamp."
  }
]

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Parameter 'timestamp' does not contain a valid Unix timestamp."
}

Get currencies available for a timestamp.

GET

https://dashbook.nownodes.io/api/v2/tickers-list

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Not available on this endpoint: the request returns HTTP 400 with {"error":"No tickers found"}.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Get currencies available for a timestamp.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/tickers-list/')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v2/tickers-list/";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v2/tickers-list/')
request = Net::HTTP::Get.new(uri)

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

{
  "ts": 1785902400,
  "available_currencies": [
    "eur",
    "usd"
  ],
  "error": "Parameter \"timestamp\" is not a valid Unix timestamp."
}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Parameter 'timestamp' is not a valid Unix timestamp."
}

BlockBook (legacy)

BlockBook (legacy) operations.

Legacy get block hash by height.

GET

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

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Legacy get block hash by height.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v1/block-index/{height}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v1/block-index/{height}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v1/block-index/{height}')
request = Net::HTTP::Get.new(uri)

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

{
  "blockHash": "0000000000000002f4e4070599fbc5dd6d0ed985f5e40a76526f977d7455f3c6"
}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Internal server error"
}

Legacy get transaction.

GET

https://dashbook.nownodes.io/api/v1/tx/{txid}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Legacy get transaction.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v1/tx/{txid}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v1/tx/{txid}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v1/tx/{txid}')
request = Net::HTTP::Get.new(uri)

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

{}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Transaction not found"
}

Legacy get address.

GET

https://dashbook.nownodes.io/api/v1/address/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Legacy get address.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v1/address/{address}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v1/address/{address}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v1/address/{address}')
request = Net::HTTP::Get.new(uri)

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

{}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Missing txid"
}

Legacy get address UTXOs.

GET

https://dashbook.nownodes.io/api/v1/utxo/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Legacy get address UTXOs.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v1/utxo/{address}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v1/utxo/{address}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v1/utxo/{address}')
request = Net::HTTP::Get.new(uri)

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

[
  {}
]

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Missing address"
}

Legacy get block by height or hash.

GET

https://dashbook.nownodes.io/api/v1/block/{blockId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Legacy get block by height or hash.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v1/block/{blockId}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v1/block/{blockId}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v1/block/{blockId}')
request = Net::HTTP::Get.new(uri)

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

{}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Block not found"
}

Legacy estimate fee target.

GET

https://dashbook.nownodes.io/api/v1/estimatefee/{blocks}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Legacy estimate fee target.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v1/estimatefee/{blocks}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v1/estimatefee/{blocks}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v1/estimatefee/{blocks}')
request = Net::HTTP::Get.new(uri)

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

{
  "result": "0.00001"
}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Parameter 'number of blocks' is not a number"
}

Legacy broadcast transaction using the path.

GET

https://dashbook.nownodes.io/api/v1/sendtx/{hex}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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.

400Bad Request

Bad Request

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

503Service Unavailable

Service Unavailable

default

Public API error.

Legacy broadcast transaction using the path.

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v1/sendtx/{hex}')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v1/sendtx/{hex}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v1/sendtx/{hex}')
request = Net::HTTP::Get.new(uri)

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

{
  "result": "65f4d6e8e6a87a0c67a17a908731dd23c7ae9a38229cdcf5fb7b67f0aab7f665"
}

{}

Unknown API_key

Method Not Allowed

Missing API_key

{}

{}

{
  "error": "Missing tx blob"
}

Legacy broadcast transaction using the request body.

POST

https://dashbook.nownodes.io/api/v1/sendtx

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

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

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.

Alternative schema variant for this parameter or payload.

string

Response

200OK

Broadcast result.

401Unauthorized

Unauthorized. Returned when the api-key header is missing, empty, or not accepted by the NOWNodes gateway. The body is plain text.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Unprocessable Entity. Returned by the NOWNodes gateway for requests it accepts but cannot process. The body is plain text.

500Internal Server Error

Internal Server Error

default

Public API error.

Legacy broadcast transaction using the request body.

curl -X POST 'https://dashbook.nownodes.io/api/v1/sendtx/' \
  -H 'Content-Type: text/plain' \
  -d '"0200000001d6aa4e52f5217cad621292450157e0e583db367597ce2beb79f2168e1d7a020b"'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v1/sendtx/')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'text/plain'
request.body = '"0200000001d6aa4e52f5217cad621292450157e0e583db367597ce2beb79f2168e1d7a020b"'

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

import requests

payload = "0200000001d6aa4e52f5217cad621292450157e0e583db367597ce2beb79f2168e1d7a020b"

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

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

const data = await response.json();

const endpoint = "https://dashbook.nownodes.io/api/v1/sendtx/";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

payload = "0200000001d6aa4e52f5217cad621292450157e0e583db367597ce2beb79f2168e1d7a020b"

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

require 'net/http'
require 'json'

uri = URI('https://dashbook.nownodes.io/api/v1/sendtx/')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'text/plain'
request.body = '"0200000001d6aa4e52f5217cad621292450157e0e583db367597ce2beb79f2168e1d7a020b"'

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

Request Body

0200000001d6aa4e52f5217cad621292450157e0e583db367597ce2beb79f2168e1d7a020b

{
  "result": "65f4d6e8e6a87a0c67a17a908731dd23c7ae9a38229cdcf5fb7b67f0aab7f665"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "result": "65f4d6e8e6a87a0c67a17a908731dd23c7ae9a38229cdcf5fb7b67f0aab7f665"
}

{
  "error": "Missing tx blob"
}

Documentation

How to migrate to NOWNodes

Authentication

Blockbook 0.6.0

BlockBook

Authorizations

Response

Authorizations

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Body

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

BlockBook (legacy)

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations