BlockBook API

v1.0.0

Base URL

https://avax-blockbook.nownodes.io

Authentication

api-keyAuthapiKey

API Key: api-key in header

MAINNET / Blockbook

BlockBook

Get Blockbook backend info

GET

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

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns general metadata and status about the Blockbook service and its connected backend node.

Response

200OK

Successfully retrieved Blockbook info

500Internal Server Error

Internal error

Get Blockbook backend info

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.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://avax-blockbook.nownodes.io/api')
data = response.json()

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

const data = await response.json();

const endpoint = "https://avax-blockbook.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://avax-blockbook.nownodes.io/api', {
  method: 'GET',
});

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.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": "Avalanche",
    "host": "blockbook-node",
    "version": "0.4.4",
    "gitCommit": "65e2800",
    "buildTime": "2022-02-12T12:34:56Z",
    "syncMode": false,
    "initialSync": false,
    "inSync": true,
    "bestHeight": 823456,
    "lastBlockTime": "2023-07-20T10:45:00Z",
    "inSyncMempool": true,
    "mempoolSize": 1023,
    "decimals": 8,
    "dbSize": 5123456789,
    "dbSizeChain": 20123456789,
    "about": "Welcome to Blockbook"
  },
  "backend": {
    "chain": "main",
    "blocks": 823456,
    "headers": 823456,
    "bestblockhash": "0000000000000000000769b1d6c56bb8f...",
    "difficulty": 482903248239.23,
    "size_on_disk": 33110011233,
    "version": "0.21.1",
    "protocolversion": 70016
  }
}

{
  "error": "Internal server error"
}

Get block hash by block height

GET

https://avax-blockbook.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 corresponding to the specified block height.

Parameters

heightinteger>= 0requiredpath

The height of the block (e.g., 800000)

Response

200OK

Successfully retrieved block hash

404Not Found

Block not found at given height

500Internal Server Error

Internal server error

Get block hash by block height

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.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://avax-blockbook.nownodes.io/api/v2/block-index/{height}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://avax-blockbook.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://avax-blockbook.nownodes.io/api/v2/block-index/{height}', {
  method: 'GET',
});

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.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": "00000000000000000004e6a25d5e8bb4d9b23f94b84f8e0cf4e2128c2b93a6b1"
}

{
  "error": "Block not found"
}

{
  "error": "Internal server error"
}

Get specific transaction details

GET

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

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns full decoded transaction data for a given transaction ID.

Parameters

txidstringrequiredpath

Transaction ID (txid) to look up

Response

200OK

Successful response with transaction details

404Not Found

Transaction not found

500Internal Server Error

Internal server error

Get specific transaction details

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.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://avax-blockbook.nownodes.io/api/v2/tx-specific/{txid}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://avax-blockbook.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://avax-blockbook.nownodes.io/api/v2/tx-specific/{txid}', {
  method: 'GET',
});

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.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)

{
  "txid": "f508de864ef389255b2d2a9c3973794cab186aeb1f47e5f9036c66e64651562a",
  "hash": "cbc797f38d2451d82abcf87a34411dfc2301013bfb2e02e603f23f79162f06e9",
  "version": 1,
  "size": 294,
  "vsize": 267,
  "weight": 1068,
  "locktime": 0,
  "vin": [
    {
      "coinbase": "03bad60d0f2f736c7573682f0d006505579f3105fabe6d6df4fa1f8b7243b5932215779ccf2859f87b3c2ab4759e5ae6767b78836d69851310000000000000000000a5f122000dd100000000",
      "txinwitness": [
        "0000000000000000000000000000000000000000000000000000000000000000"
      ],
      "sequence": 4294967295
    }
  ],
  "vout": [
    {
      "value": 3.16083585,
      "n": 0,
      "scriptPubKey": {
        "asm": "OP_HASH160 1f0cbbec8bc4c945e4e16249b11eee911eded55f OP_EQUAL",
        "desc": "addr(34XC8GbijKCCvppNvhw4Ra8QZdWsg8tC11)#08lwrngg",
        "hex": "a9141f0cbbec8bc4c945e4e16249b11eee911eded55f87",
        "address": "34XC8GbijKCCvppNvhw4Ra8QZdWsg8tC11",
        "type": "scripthash"
      }
    }
  ],
  "hex": "010000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff4c03bad60d0f2f736c7573682f0d006505579f3105fabe6d6df4fa1f8b7243b5932215779ccf2859f87b3c2ab4759e5ae6767b78836d69851310000000000000000000a5f122000dd100000000ffffffff03810dd7120000000017a9141f0cbbec8bc4c945e4e16249b11eee911eded55f870000000000000000266a24aa21a9eda0eefc77c01fe976be38c09d179d818253863e0c2e0ceb8718a75b66a0f0251500000000000000002b6a2952534b424c4f434b3a45ace0e0b600b6c87a591f975cc9f3eaecc5d6476173a2f8d1827117007733ae0120000000000000000000000000000000000000000000000000000000000000000000000000",
  "blockhash": "0000000000000000000050fec987e125eab4ea779162a1cdf7ed05bb3535f24e",
  "confirmations": 1,
  "time": 1753349199,
  "blocktime": 1753349199
}

{
  "error": "Transaction not found"
}

{
  "error": "Internal server error"
}

Get address information

GET

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

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns detailed information about a Bitcoin address such as balance, total received and sent, unconfirmed transactions, list of txids, and more. Supports pagination and filtering by block height and details.

Parameters

addressstringrequiredpath

Bitcoin address to query.

pageinteger1query

Page number for pagination (default is 1).

pageSizeinteger1000query

Number of items per page (default 1000).

fromintegerquery

Starting block height to filter transactions (optional).

tointegerquery

Ending block height to filter transactions (optional).

detailsstringbasictokenstokenBalancestxidstxsquery

Level of transaction detail to return. Options:

basic: Basic transaction info.
tokens: Include token info.
tokenBalances: Include token balances.
txids: Return only transaction IDs.
txs: Return full transaction details.

contractstringquery

Filter by contract address (optional).

secondarystringquery

Include secondary currency balances (e.g., USD).

Response

200OK

Successful response with address details

400Bad Request

Invalid address or bad request

404Not Found

Address not found

500Internal Server Error

Internal server error

Get address information

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.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://avax-blockbook.nownodes.io/api/v2/address/{address}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://avax-blockbook.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://avax-blockbook.nownodes.io/api/v2/address/{address}', {
  method: 'GET',
});

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.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": 1,
  "itemsOnPage": 1000,
  "address": "bc1qll4224u6ecldm02xs250h20ax9u6dc4pl9332d",
  "balance": "0",
  "totalReceived": "4555309",
  "totalSent": "4555309",
  "unconfirmedBalance": "0",
  "unconfirmedTxs": 0,
  "txs": 2,
  "txids": [
    "99446b8a7d2d61301ef6d4e34d65ee179da9d15daec46d8ca746ce9984ba31d1",
    "44d575c325e9ee502a67364b1d9537d3d3233f4047bbae42888838ececb8cf86"
  ]
}

{
  "error": "Invalid address format"
}

{
  "error": "Address not found"
}

{
  "error": "Internal server error"
}

Get XPUB or descriptor details

GET

https://avax-blockbook.nownodes.io/api/v2/xpub/{xpubOrDescriptor}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieves detailed information about an XPUB or descriptor including confirmed balance, total received and sent amounts, unconfirmed balances, transaction counts, tokens used, and paginated transaction IDs.

Parameters

xpubOrDescriptorstringrequiredpath

XPUB or descriptor to query.

pageinteger1query

Page number for pagination (default is 1).

pageSizeinteger1000query

Number of items per page (default 1000).

fromintegerquery

Starting block height to filter transactions (optional).

tointegerquery

Ending block height to filter transactions (optional).

detailsstringbasictokenstokenBalancestxidstxsquery

Level of transaction detail to return. Options:

basic: Basic transaction info.
tokens: Include token info.
tokenBalances: Include token balances.
txids: Return only transaction IDs.
txs: Return full transaction details.

tokensstringnonzerousedderivedquery

Filter tokens by usage type:

nonzero: Tokens with non-zero balances.
used: Tokens that have been used.
derived: Tokens derived from this XPUB.

secondarystringquery

Include secondary currency balances (e.g., EUR).

Response

200OK

Successful response with XPUB details

400Bad Request

Invalid XPUB or bad request

404Not Found

XPUB not found

500Internal Server Error

Internal server error

Get XPUB or descriptor details

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.nownodes.io/api/v2/xpub/{xpubOrDescriptor}')
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://avax-blockbook.nownodes.io/api/v2/xpub/{xpubOrDescriptor}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://avax-blockbook.nownodes.io/api/v2/xpub/{xpubOrDescriptor}";
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://avax-blockbook.nownodes.io/api/v2/xpub/{xpubOrDescriptor}', {
  method: 'GET',
});

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.nownodes.io/api/v2/xpub/{xpubOrDescriptor}')
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": "xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB",
  "balance": "0",
  "totalReceived": "2063000",
  "totalSent": "2063000",
  "unconfirmedBalance": "0",
  "unconfirmedTxs": 0,
  "txs": 18,
  "addrTxCount": 18,
  "txids": [
    "b435109b7e6ad2b8181583cbf51fcdefe618959cf8bc4f7d45b6d1f5c0c79f89",
    "06577f9c46abed29c32a6f3921dc3bf3cfb2b2f8e7e0b96d281b8ca4e26185d9",
    "9e29a01ca3bb3aa878d25279dc0761efb34de402744ef46b94c057f964ed8628",
    "657f6e76df55a65356d98371370e9f512d1c5d41a01d0d12467edc0609640444",
    "5256a1c98272d1525b46d96b4c01abe62737b8b5932df313c535ab7ebfd4658f",
    "9f127de1c7dc91ef69bec8f0ec5900bda86cec65cb9ace25b6507d410c478a65",
    "9146c7e0a9e7d3d7dd0c4be8bce00d088a25a0bae333d00f22f559a566d7fa41",
    "5caa0c516b2e39b560b7ccfee86824c001e798d20b72e9ea58b3284c46c77d18",
    "90c36964f0e161dcbe054d5201e4fbb8e51782289658893eb00d5dab4547750a",
    "c8d3da26fd0e5a98ef15856becee55fddd2178b8c4fdc786f116251d04bc444d",
    "80c7b9836ae6156a1574f380bb277c712405ebc8e415e34ae61653b2212c7be8",
    "3abc1608b70f0ed319a9a43eb5ed631c39ff8ff57b717652ab45a0c9729ef6ac",
    "62cca9c94fbc618df729d0f1f937222bc9be9de153d7cb1abd4abafdd4f5f1b5",
    "8a82f253ca23b870f2b2f23d3a3cb3aeb26057e21431c35d5f48bd40d78d7c30",
    "99e6806d5253649a758d3e23c66fb48642fd321efdebf4eb1ae78cbdd2fdc8df",
    "318d068ea98fb1ce64cfacf3bd992b87fb78be52289cad14d1ccfd4d472d964f",
    "66a4185ef490e31434e2f11fdf22fc0e58c5acef1b744cb0598daae2979acfce",
    "6398de55c404e897b60cf19f55ab9d9daee95227378164c1a89a820b4d4e779b"
  ],
  "usedTokens": 9
}

{
  "error": "Invalid XPUB format"
}

{
  "error": "XPUB not found"
}

{
  "error": "Internal server error"
}

Get UTXOs for address, XPUB or descriptor

GET

https://avax-blockbook.nownodes.io/api/v2/utxo/{addressOrXpubOrDescriptor}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieves the unspent transaction outputs (UTXOs) associated with a specific address, XPUB, or descriptor. Optionally filter only confirmed UTXOs by using the confirmed query parameter.

Parameters

addressOrXpubOrDescriptorstringrequiredpath

Address, XPUB or descriptor to query UTXOs for.

confirmedbooleanfalsequery

If true, only return confirmed UTXOs. Defaults to false (returns both confirmed and unconfirmed).

Response

200OK

List of UTXOs for the given address, XPUB, or descriptor

400Bad Request

Invalid address or parameter error

404Not Found

No UTXOs found for the specified input

500Internal Server Error

Internal server error

Get UTXOs for address, XPUB or descriptor

curl -X GET 'https://avax-blockbook.nownodes.io/api/v2/utxo/{addressOrXpubOrDescriptor}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.nownodes.io/api/v2/utxo/{addressOrXpubOrDescriptor}')
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://avax-blockbook.nownodes.io/api/v2/utxo/{addressOrXpubOrDescriptor}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://avax-blockbook.nownodes.io/api/v2/utxo/{addressOrXpubOrDescriptor}";
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://avax-blockbook.nownodes.io/api/v2/utxo/{addressOrXpubOrDescriptor}', {
  method: 'GET',
});

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.nownodes.io/api/v2/utxo/{addressOrXpubOrDescriptor}')
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": "99446b8a7d2d61301ef6d4e34d65ee179da9d15daec46d8ca746ce9984ba31d1",
    "vout": 0,
    "value": "4555309",
    "height": 700000,
    "confirmations": 100,
    "coinbase": false,
    "spent": false
  },
  {
    "txid": "44d575c325e9ee502a67364b1d9537d3d3233f4047bbae42888838ececb8cf86",
    "vout": 1,
    "value": "1000000",
    "height": 699900,
    "confirmations": 200,
    "coinbase": true,
    "spent": false
  }
]

{
  "error": "Invalid address format"
}

{
  "error": "No UTXOs found"
}

{
  "error": "Internal server error"
}

Get block details by height or hash

GET

https://avax-blockbook.nownodes.io/api/v2/block/{blockHeightOrHash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns detailed information about a block specified by its height or hash.

Parameters

blockHeightOrHashstringrequiredpath

Block height (integer) or block hash (string) to identify the block.

Response

200OK

Block details response

400Bad Request

Invalid block height or hash format

404Not Found

Block not found

500Internal Server Error

Internal server error

Get block details by height or hash

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.nownodes.io/api/v2/block/{blockHeightOrHash}')
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://avax-blockbook.nownodes.io/api/v2/block/{blockHeightOrHash}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://avax-blockbook.nownodes.io/api/v2/block/{blockHeightOrHash}";
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://avax-blockbook.nownodes.io/api/v2/block/{blockHeightOrHash}', {
  method: 'GET',
});

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.nownodes.io/api/v2/block/{blockHeightOrHash}')
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)

{
  "hash": "0000000000000000000a1b2c3d4e5f67890abcdef1234567890abcdef1234567",
  "confirmations": 123,
  "size": 1234567,
  "height": 700000,
  "version": 536870912,
  "merkleroot": "4d5e6f7890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
  "tx": [
    "f508de864ef389255b2d2a9c3973794cab186aeb1f47e5f9036c66e64651562a",
    "cbc797f38d2451d82abcf87a34411dfc2301013bfb2e02e603f23f79162f06e9"
  ],
  "time": 1753349199,
  "nonce": 2083236893,
  "bits": "1d00ffff",
  "difficulty": 19354847804972.85,
  "previousblockhash": "0000000000000000000872af0a1b2c3d4e5f67890abcdef1234567890abcdef1",
  "nextblockhash": "0000000000000000000b3c4d5e6f7890abcdef1234567890abcdef1234567890"
}

{
  "error": "Invalid block height or hash"
}

{
  "error": "Block not found"
}

{
  "error": "Internal server error"
}

Broadcast raw transaction

GET

https://avax-blockbook.nownodes.io/api/v2/sendtx/{hexTxData}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Sends a raw transaction to the blockchain network. The transaction must be provided as a hex-encoded string in the URL path.

Parameters

hexTxDatastringrequiredpath

Hex-encoded raw transaction data to be broadcasted.

Response

200OK

Transaction broadcast successful

400Bad Request

Invalid transaction hex data

500Internal Server Error

Internal server error

Broadcast raw transaction

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.nownodes.io/api/v2/sendtx/{hexTxData}')
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://avax-blockbook.nownodes.io/api/v2/sendtx/{hexTxData}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://avax-blockbook.nownodes.io/api/v2/sendtx/{hexTxData}";
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://avax-blockbook.nownodes.io/api/v2/sendtx/{hexTxData}', {
  method: 'GET',
});

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.nownodes.io/api/v2/sendtx/{hexTxData}')
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": "f508de864ef389255b2d2a9c3973794cab186aeb1f47e5f9036c66e64651562a",
  "result": "Transaction broadcasted successfully"
}

{
  "error": "Invalid hex transaction data"
}

{
  "error": "Internal server error"
}

Get list of tickers updated since timestamp

GET

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

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an array of ticker objects representing cryptocurrency prices updated since the specified UNIX timestamp (in seconds).

Parameters

timestampintegerquery

UNIX timestamp (in seconds). Only tickers updated after this time are returned.

Response

200OK

List of tickers

400Bad Request

Invalid timestamp parameter

500Internal Server Error

Internal server error

Get list of tickers updated since timestamp

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.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://avax-blockbook.nownodes.io/api/v2/tickers-list')
data = response.json()

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

const data = await response.json();

const endpoint = "https://avax-blockbook.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://avax-blockbook.nownodes.io/api/v2/tickers-list', {
  method: 'GET',
});

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.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)

[
  {
    "symbol": "BTC",
    "price": "26859.45",
    "timestamp": 1680001234
  },
  {
    "symbol": "ETH",
    "price": "1875.32",
    "timestamp": 1680001250
  }
]

{
  "error": "Invalid timestamp parameter"
}

{
  "error": "Internal server error"
}

Get balance history for an address or XPUB

GET

https://avax-blockbook.nownodes.io/api/v2/balancehistory/{account}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the balance history for the specified address or XPUB between the from and to date parameters. The balances can be optionally converted to a specified fiat currency and grouped by time intervals.

Parameters

accountstringrequiredpath

XPUB or address to query balance history for

fromstring<date-time>requiredquery

Start date (ISO 8601 format, e.g. 2023-01-01T00:00:00Z)

tostring<date-time>requiredquery

End date (ISO 8601 format, e.g. 2023-01-10T00:00:00Z)

fiatcurrencystringquery

Fiat currency code to convert balances (e.g., USD, EUR). Optional.

groupByintegerquery

Group results by time interval in seconds (e.g., 86400 for daily). Optional.

Response

200OK

Balance history retrieved successfully

400Bad Request

Invalid or missing parameters

500Internal Server Error

Internal server error

Get balance history for an address or XPUB

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.nownodes.io/api/v2/balancehistory/{account}')
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://avax-blockbook.nownodes.io/api/v2/balancehistory/{account}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://avax-blockbook.nownodes.io/api/v2/balancehistory/{account}";
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://avax-blockbook.nownodes.io/api/v2/balancehistory/{account}', {
  method: 'GET',
});

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://avax-blockbook.nownodes.io/api/v2/balancehistory/{account}')
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)

{
  "account": "xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB",
  "from": "2023-01-01T00:00:00Z",
  "to": "2023-01-10T00:00:00Z",
  "fiatcurrency": "USD",
  "groupBy": 86400,
  "history": [
    {
      "timestamp": "2023-01-01T00:00:00Z",
      "balance": "0.10000000",
      "balanceFiat": "4200.00"
    },
    {
      "timestamp": "2023-01-02T00:00:00Z",
      "balance": "0.10500000",
      "balanceFiat": "4410.00"
    },
    {
      "timestamp": "2023-01-03T00:00:00Z",
      "balance": "0.10300000",
      "balanceFiat": "4320.00"
    },
    {
      "timestamp": "2023-01-04T00:00:00Z",
      "balance": "0.11000000",
      "balanceFiat": "4620.00"
    },
    {
      "timestamp": "2023-01-05T00:00:00Z",
      "balance": "0.11500000",
      "balanceFiat": "4830.00"
    },
    {
      "timestamp": "2023-01-06T00:00:00Z",
      "balance": "0.11200000",
      "balanceFiat": "4700.00"
    },
    {
      "timestamp": "2023-01-07T00:00:00Z",
      "balance": "0.11800000",
      "balanceFiat": "4950.00"
    },
    {
      "timestamp": "2023-01-08T00:00:00Z",
      "balance": "0.12000000",
      "balanceFiat": "5040.00"
    },
    {
      "timestamp": "2023-01-09T00:00:00Z",
      "balance": "0.12500000",
      "balanceFiat": "5250.00"
    },
    {
      "timestamp": "2023-01-10T00:00:00Z",
      "balance": "0.13000000",
      "balanceFiat": "5460.00"
    }
  ]
}

{
  "error": "Invalid date format for parameter 'from'"
}

{
  "error": "Internal server error"
}

Documentation

How to migrate to NOWNodes

Authentication

MAINNET / Blockbook

BlockBook

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

Parameters

Response