BlockBook API

v1.0.0

Base URLs

https://avax-blockbook.nownodes.io

https://avax.nownodes.io/ext/bc/C/rpc

https://avax.nownodes.io

https://avax.nownodes.io/ext/index/{chain}/{container}

https://avax.nownodes.io/ext/bc/P

https://avax.nownodes.io/ext/bc/X

https://avax.nownodes.io/ext/bc/X/wallet

Authentication

api-keyAuthapiKey

API Key: api-key in header

MAINNET / Blockbook

BlockBook

Get Blockbook backend info

GET

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

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

Authorization

api-keyAuthapiKey in header

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();

import requests

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

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

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

Authorization

api-keyAuthapiKey in header

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();

import requests

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

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

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

Authorization

api-keyAuthapiKey in header

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();

import requests

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

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

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

Authorization

api-keyAuthapiKey in header

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();

import requests

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

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

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

Authorization

api-keyAuthapiKey in header

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();

import requests

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

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

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

Authorization

api-keyAuthapiKey in header

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();

import requests

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

[
  {
    "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}

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

Authorization

api-keyAuthapiKey in header

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();

import requests

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

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

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

Authorization

api-keyAuthapiKey in header

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();

import requests

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

{
  "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

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

Authorization

api-keyAuthapiKey in header

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();

import requests

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

[
  {
    "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}

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

Authorization

api-keyAuthapiKey in header

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();

import requests

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

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

MAINNET / C-Chain

C-Chain

avalanche.getAtomicTx

POST

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

Get an atomic transaction.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringavalanche.getAtomicTxrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

avalanche.getAtomicTx

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "avalanche.getAtomicTx",
    "params": {
      "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9",
      "encoding": "hex"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "avalanche.getAtomicTx",
      "params": {
        "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9",
        "encoding": "hex"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avalanche.getAtomicTx",
  "params": {
    "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9",
    "encoding": "hex"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avalanche.getAtomicTx",
  "params": {
    "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9",
    "encoding": "hex"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "tx": "0x0000",
    "encoding": "hex"
  }
}

avalanche.getUTXOs

POST

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

Get atomic UTXOs available to the C-Chain.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringavalanche.getUTXOsrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

avalanche.getUTXOs

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "avalanche.getUTXOs",
    "params": {
      "addresses": [
        "C-avax1..."
      ],
      "sourceChain": "X",
      "limit": 1024,
      "encoding": "hex"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "avalanche.getUTXOs",
      "params": {
        "addresses": [
          "C-avax1..."
        ],
        "sourceChain": "X",
        "limit": 1024,
        "encoding": "hex"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avalanche.getUTXOs",
  "params": {
    "addresses": [
      "C-avax1..."
    ],
    "sourceChain": "X",
    "limit": 1024,
    "encoding": "hex"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avalanche.getUTXOs",
  "params": {
    "addresses": [
      "C-avax1..."
    ],
    "sourceChain": "X",
    "limit": 1024,
    "encoding": "hex"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "numFetched": "0",
    "utxos": [],
    "endIndex": {
      "address": "",
      "utxo": ""
    },
    "encoding": "hex"
  }
}

avalanche.issueTx

POST

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

Issue an atomic transaction to the C-Chain.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringavalanche.issueTxrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

avalanche.issueTx

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "avalanche.issueTx",
    "params": {
      "tx": "0x0000",
      "encoding": "hex"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "avalanche.issueTx",
      "params": {
        "tx": "0x0000",
        "encoding": "hex"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avalanche.issueTx",
  "params": {
    "tx": "0x0000",
    "encoding": "hex"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avalanche.issueTx",
  "params": {
    "tx": "0x0000",
    "encoding": "hex"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9"
  }
}

eth_accounts

POST

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

Return addresses owned by the client.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_accountsrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_accounts

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_accounts",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_accounts",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_accounts",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_accounts",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": []
}

eth_baseFee

POST

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

Return the current C-Chain base fee.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_baseFeerequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_baseFee

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_baseFee",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_baseFee",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_baseFee",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_baseFee",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x5d21dba00"
}

eth_blockNumber

POST

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

Return the latest block number.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_blockNumberrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_blockNumber

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_blockNumber",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_blockNumber",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_blockNumber",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_blockNumber",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x2faf080"
}

eth_call

POST

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

Execute a call without creating a transaction.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_callrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_call

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_call",
    "params": {
      "transaction": {
        "to": "0x0000000000000000000000000000000000000000",
        "data": "0x"
      },
      "block": "latest"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_call",
      "params": {
        "transaction": {
          "to": "0x0000000000000000000000000000000000000000",
          "data": "0x"
        },
        "block": "latest"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_call",
  "params": {
    "transaction": {
      "to": "0x0000000000000000000000000000000000000000",
      "data": "0x"
    },
    "block": "latest"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_call",
  "params": {
    "transaction": {
      "to": "0x0000000000000000000000000000000000000000",
      "data": "0x"
    },
    "block": "latest"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x"
}

eth_chainId

POST

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

Return the C-Chain ID.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_chainIdrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_chainId

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_chainId",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_chainId",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_chainId",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_chainId",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0xa86a"
}

eth_coinbase

POST

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

Return the client coinbase address.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_coinbaserequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_coinbase

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_coinbase",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_coinbase",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_coinbase",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_coinbase",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x0000000000000000000000000000000000000000"
}

eth_estimateGas

POST

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

Estimate the gas required for a transaction.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_estimateGasrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_estimateGas

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_estimateGas",
    "params": {
      "transaction": {
        "to": "0x0000000000000000000000000000000000000000",
        "data": "0x"
      }
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_estimateGas",
      "params": {
        "transaction": {
          "to": "0x0000000000000000000000000000000000000000",
          "data": "0x"
        }
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_estimateGas",
  "params": {
    "transaction": {
      "to": "0x0000000000000000000000000000000000000000",
      "data": "0x"
    }
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_estimateGas",
  "params": {
    "transaction": {
      "to": "0x0000000000000000000000000000000000000000",
      "data": "0x"
    }
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x5208"
}

eth_feeHistory

POST

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

Return historical fee information.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_feeHistoryrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_feeHistory

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_feeHistory",
    "params": {
      "blockCount": "0x4",
      "newestBlock": "latest",
      "rewardPercentiles": [
        25,
        50,
        75
      ]
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_feeHistory",
      "params": {
        "blockCount": "0x4",
        "newestBlock": "latest",
        "rewardPercentiles": [
          25,
          50,
          75
        ]
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_feeHistory",
  "params": {
    "blockCount": "0x4",
    "newestBlock": "latest",
    "rewardPercentiles": [
      25,
      50,
      75
    ]
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_feeHistory",
  "params": {
    "blockCount": "0x4",
    "newestBlock": "latest",
    "rewardPercentiles": [
      25,
      50,
      75
    ]
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "oldestBlock": "0x1",
    "baseFeePerGas": [
      "0x1"
    ],
    "gasUsedRatio": [
      0.5
    ],
    "reward": [
      [
        "0x0"
      ]
    ]
  }
}

eth_gasPrice

POST

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

Return the current gas price.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_gasPricerequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_gasPrice

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_gasPrice",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_gasPrice",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_gasPrice",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_gasPrice",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x5d21dba00"
}

eth_getAssetBalance

POST

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

Return the balance of an Avalanche native asset held by an EVM address.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getAssetBalancerequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getAssetBalance

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getAssetBalance",
    "params": {
      "address": "0x0000000000000000000000000000000000000000",
      "assetID": "FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z",
      "block": "latest"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getAssetBalance",
      "params": {
        "address": "0x0000000000000000000000000000000000000000",
        "assetID": "FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z",
        "block": "latest"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getAssetBalance",
  "params": {
    "address": "0x0000000000000000000000000000000000000000",
    "assetID": "FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z",
    "block": "latest"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getAssetBalance",
  "params": {
    "address": "0x0000000000000000000000000000000000000000",
    "assetID": "FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z",
    "block": "latest"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x0"
}

eth_getBalance

POST

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

Return the balance of an address.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getBalancerequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getBalance

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getBalance",
    "params": {
      "address": "0x0000000000000000000000000000000000000000",
      "block": "latest"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getBalance",
      "params": {
        "address": "0x0000000000000000000000000000000000000000",
        "block": "latest"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getBalance",
  "params": {
    "address": "0x0000000000000000000000000000000000000000",
    "block": "latest"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getBalance",
  "params": {
    "address": "0x0000000000000000000000000000000000000000",
    "block": "latest"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x0"
}

eth_getBlockByHash

POST

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

Return a block by hash.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getBlockByHashrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getBlockByHash

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getBlockByHash",
    "params": {
      "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111",
      "fullTransactions": false
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getBlockByHash",
      "params": {
        "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111",
        "fullTransactions": false
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getBlockByHash",
  "params": {
    "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111",
    "fullTransactions": False
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getBlockByHash",
  "params": {
    "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111",
    "fullTransactions": false
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "number": "0x1",
    "hash": "0x1111111111111111111111111111111111111111111111111111111111111111",
    "transactions": []
  }
}

eth_getBlockByNumber

POST

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

Return a block by number.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getBlockByNumberrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getBlockByNumber

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getBlockByNumber",
    "params": {
      "block": "latest",
      "fullTransactions": false
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getBlockByNumber",
      "params": {
        "block": "latest",
        "fullTransactions": false
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getBlockByNumber",
  "params": {
    "block": "latest",
    "fullTransactions": False
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getBlockByNumber",
  "params": {
    "block": "latest",
    "fullTransactions": false
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "number": "0x1",
    "hash": "0x1111111111111111111111111111111111111111111111111111111111111111",
    "transactions": []
  }
}

eth_getBlockTransactionCountByHash

POST

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

Return the number of transactions in a block by hash.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getBlockTransactionCountByHashrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getBlockTransactionCountByHash

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getBlockTransactionCountByHash",
    "params": {
      "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getBlockTransactionCountByHash",
      "params": {
        "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getBlockTransactionCountByHash",
  "params": {
    "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getBlockTransactionCountByHash",
  "params": {
    "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x1"
}

eth_getBlockTransactionCountByNumber

POST

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

Return the number of transactions in a block by number.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getBlockTransactionCountByNumberrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getBlockTransactionCountByNumber

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getBlockTransactionCountByNumber",
    "params": {
      "block": "latest"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getBlockTransactionCountByNumber",
      "params": {
        "block": "latest"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getBlockTransactionCountByNumber",
  "params": {
    "block": "latest"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getBlockTransactionCountByNumber",
  "params": {
    "block": "latest"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x1"
}

eth_getCode

POST

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

Return contract bytecode.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getCoderequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getCode

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getCode",
    "params": {
      "address": "0x0000000000000000000000000000000000000000",
      "block": "latest"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getCode",
      "params": {
        "address": "0x0000000000000000000000000000000000000000",
        "block": "latest"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getCode",
  "params": {
    "address": "0x0000000000000000000000000000000000000000",
    "block": "latest"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getCode",
  "params": {
    "address": "0x0000000000000000000000000000000000000000",
    "block": "latest"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x"
}

eth_getFilterChanges

POST

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

Return changes since the last filter poll.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getFilterChangesrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getFilterChanges

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getFilterChanges",
    "params": {
      "filterID": "0x1"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getFilterChanges",
      "params": {
        "filterID": "0x1"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getFilterChanges",
  "params": {
    "filterID": "0x1"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getFilterChanges",
  "params": {
    "filterID": "0x1"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": []
}

eth_getFilterLogs

POST

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

Return all logs matching a filter.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getFilterLogsrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getFilterLogs

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getFilterLogs",
    "params": {
      "filterID": "0x1"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getFilterLogs",
      "params": {
        "filterID": "0x1"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getFilterLogs",
  "params": {
    "filterID": "0x1"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getFilterLogs",
  "params": {
    "filterID": "0x1"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": []
}

eth_getLogs

POST

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

Return logs matching a filter.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getLogsrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getLogs

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getLogs",
    "params": {
      "filter": {
        "fromBlock": "latest",
        "toBlock": "latest"
      }
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getLogs",
      "params": {
        "filter": {
          "fromBlock": "latest",
          "toBlock": "latest"
        }
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getLogs",
  "params": {
    "filter": {
      "fromBlock": "latest",
      "toBlock": "latest"
    }
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getLogs",
  "params": {
    "filter": {
      "fromBlock": "latest",
      "toBlock": "latest"
    }
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": []
}

eth_getStorageAt

POST

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

Return a storage value from a contract.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getStorageAtrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getStorageAt

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getStorageAt",
    "params": {
      "address": "0x0000000000000000000000000000000000000000",
      "position": "0x0",
      "block": "latest"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getStorageAt",
      "params": {
        "address": "0x0000000000000000000000000000000000000000",
        "position": "0x0",
        "block": "latest"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getStorageAt",
  "params": {
    "address": "0x0000000000000000000000000000000000000000",
    "position": "0x0",
    "block": "latest"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getStorageAt",
  "params": {
    "address": "0x0000000000000000000000000000000000000000",
    "position": "0x0",
    "block": "latest"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x0000000000000000000000000000000000000000000000000000000000000000"
}

eth_getTransactionByBlockHashAndIndex

POST

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

Return a transaction by block hash and index.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getTransactionByBlockHashAndIndexrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getTransactionByBlockHashAndIndex

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getTransactionByBlockHashAndIndex",
    "params": {
      "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111",
      "index": "0x0"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getTransactionByBlockHashAndIndex",
      "params": {
        "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111",
        "index": "0x0"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getTransactionByBlockHashAndIndex",
  "params": {
    "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111",
    "index": "0x0"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getTransactionByBlockHashAndIndex",
  "params": {
    "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111",
    "index": "0x0"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "hash": "0x2222222222222222222222222222222222222222222222222222222222222222"
  }
}

eth_getTransactionByBlockNumberAndIndex

POST

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

Return a transaction by block number and index.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getTransactionByBlockNumberAndIndexrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getTransactionByBlockNumberAndIndex

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getTransactionByBlockNumberAndIndex",
    "params": {
      "block": "latest",
      "index": "0x0"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getTransactionByBlockNumberAndIndex",
      "params": {
        "block": "latest",
        "index": "0x0"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getTransactionByBlockNumberAndIndex",
  "params": {
    "block": "latest",
    "index": "0x0"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getTransactionByBlockNumberAndIndex",
  "params": {
    "block": "latest",
    "index": "0x0"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "hash": "0x2222222222222222222222222222222222222222222222222222222222222222"
  }
}

eth_getTransactionByHash

POST

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

Return a transaction by hash.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getTransactionByHashrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getTransactionByHash

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getTransactionByHash",
    "params": {
      "transactionHash": "0x2222222222222222222222222222222222222222222222222222222222222222"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getTransactionByHash",
      "params": {
        "transactionHash": "0x2222222222222222222222222222222222222222222222222222222222222222"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getTransactionByHash",
  "params": {
    "transactionHash": "0x2222222222222222222222222222222222222222222222222222222222222222"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getTransactionByHash",
  "params": {
    "transactionHash": "0x2222222222222222222222222222222222222222222222222222222222222222"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "hash": "0x2222222222222222222222222222222222222222222222222222222222222222",
    "blockNumber": "0x1",
    "from": "0x0000000000000000000000000000000000000000",
    "to": "0x0000000000000000000000000000000000000001"
  }
}

eth_getTransactionCount

POST

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

Return the transaction count for an address.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getTransactionCountrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getTransactionCount

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getTransactionCount",
    "params": {
      "address": "0x0000000000000000000000000000000000000000",
      "block": "latest"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getTransactionCount",
      "params": {
        "address": "0x0000000000000000000000000000000000000000",
        "block": "latest"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getTransactionCount",
  "params": {
    "address": "0x0000000000000000000000000000000000000000",
    "block": "latest"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getTransactionCount",
  "params": {
    "address": "0x0000000000000000000000000000000000000000",
    "block": "latest"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x0"
}

eth_getTransactionReceipt

POST

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

Return a transaction receipt.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getTransactionReceiptrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getTransactionReceipt

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getTransactionReceipt",
    "params": {
      "transactionHash": "0x2222222222222222222222222222222222222222222222222222222222222222"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getTransactionReceipt",
      "params": {
        "transactionHash": "0x2222222222222222222222222222222222222222222222222222222222222222"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getTransactionReceipt",
  "params": {
    "transactionHash": "0x2222222222222222222222222222222222222222222222222222222222222222"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getTransactionReceipt",
  "params": {
    "transactionHash": "0x2222222222222222222222222222222222222222222222222222222222222222"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "transactionHash": "0x2222222222222222222222222222222222222222222222222222222222222222",
    "status": "0x1",
    "logs": []
  }
}

eth_getUncleByBlockHashAndIndex

POST

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

Return an uncle block by block hash and index.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getUncleByBlockHashAndIndexrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getUncleByBlockHashAndIndex

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getUncleByBlockHashAndIndex",
    "params": {
      "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111",
      "index": "0x0"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getUncleByBlockHashAndIndex",
      "params": {
        "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111",
        "index": "0x0"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getUncleByBlockHashAndIndex",
  "params": {
    "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111",
    "index": "0x0"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getUncleByBlockHashAndIndex",
  "params": {
    "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111",
    "index": "0x0"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": null
}

eth_getUncleByBlockNumberAndIndex

POST

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

Return an uncle block by block number and index.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getUncleByBlockNumberAndIndexrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getUncleByBlockNumberAndIndex

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getUncleByBlockNumberAndIndex",
    "params": {
      "block": "latest",
      "index": "0x0"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getUncleByBlockNumberAndIndex",
      "params": {
        "block": "latest",
        "index": "0x0"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getUncleByBlockNumberAndIndex",
  "params": {
    "block": "latest",
    "index": "0x0"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getUncleByBlockNumberAndIndex",
  "params": {
    "block": "latest",
    "index": "0x0"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": null
}

eth_getUncleCountByBlockHash

POST

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

Return the uncle count by block hash.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getUncleCountByBlockHashrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getUncleCountByBlockHash

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getUncleCountByBlockHash",
    "params": {
      "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getUncleCountByBlockHash",
      "params": {
        "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getUncleCountByBlockHash",
  "params": {
    "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getUncleCountByBlockHash",
  "params": {
    "blockHash": "0x1111111111111111111111111111111111111111111111111111111111111111"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x0"
}

eth_getUncleCountByBlockNumber

POST

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

Return the uncle count by block number.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_getUncleCountByBlockNumberrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_getUncleCountByBlockNumber

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getUncleCountByBlockNumber",
    "params": {
      "block": "latest"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_getUncleCountByBlockNumber",
      "params": {
        "block": "latest"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getUncleCountByBlockNumber",
  "params": {
    "block": "latest"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getUncleCountByBlockNumber",
  "params": {
    "block": "latest"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x0"
}

eth_hashrate

POST

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

Return hashes per second.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_hashraterequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_hashrate

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_hashrate",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_hashrate",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_hashrate",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_hashrate",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x0"
}

eth_maxPriorityFeePerGas

POST

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

Return a suggested priority fee per gas.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_maxPriorityFeePerGasrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_maxPriorityFeePerGas

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_maxPriorityFeePerGas",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_maxPriorityFeePerGas",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_maxPriorityFeePerGas",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_maxPriorityFeePerGas",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x0"
}

eth_mining

POST

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

Return whether the client is mining.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_miningrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_mining

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_mining",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_mining",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_mining",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_mining",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": false
}

eth_newBlockFilter

POST

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

Create a block filter.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_newBlockFilterrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_newBlockFilter

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_newBlockFilter",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_newBlockFilter",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_newBlockFilter",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_newBlockFilter",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x1"
}

eth_newFilter

POST

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

Create a log filter.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_newFilterrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_newFilter

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_newFilter",
    "params": {
      "filter": {
        "fromBlock": "latest",
        "toBlock": "latest",
        "address": "0x0000000000000000000000000000000000000000"
      }
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_newFilter",
      "params": {
        "filter": {
          "fromBlock": "latest",
          "toBlock": "latest",
          "address": "0x0000000000000000000000000000000000000000"
        }
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_newFilter",
  "params": {
    "filter": {
      "fromBlock": "latest",
      "toBlock": "latest",
      "address": "0x0000000000000000000000000000000000000000"
    }
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_newFilter",
  "params": {
    "filter": {
      "fromBlock": "latest",
      "toBlock": "latest",
      "address": "0x0000000000000000000000000000000000000000"
    }
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x1"
}

eth_newPendingTransactionFilter

POST

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

Create a pending transaction filter.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_newPendingTransactionFilterrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_newPendingTransactionFilter

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_newPendingTransactionFilter",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_newPendingTransactionFilter",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_newPendingTransactionFilter",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_newPendingTransactionFilter",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x1"
}

eth_protocolVersion

POST

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

Return the Ethereum protocol version.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_protocolVersionrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_protocolVersion

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_protocolVersion",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_protocolVersion",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_protocolVersion",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_protocolVersion",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x41"
}

eth_sendRawTransaction

POST

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

Broadcast a signed raw transaction.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_sendRawTransactionrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_sendRawTransaction

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_sendRawTransaction",
    "params": {
      "data": "0x02f8..."
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_sendRawTransaction",
      "params": {
        "data": "0x02f8..."
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_sendRawTransaction",
  "params": {
    "data": "0x02f8..."
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_sendRawTransaction",
  "params": {
    "data": "0x02f8..."
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x2222222222222222222222222222222222222222222222222222222222222222"
}

eth_sendTransaction

POST

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

Create, sign, and broadcast a transaction.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_sendTransactionrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_sendTransaction

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_sendTransaction",
    "params": {
      "transaction": {
        "from": "0x0000000000000000000000000000000000000000",
        "to": "0x0000000000000000000000000000000000000001",
        "value": "0x0"
      }
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_sendTransaction",
      "params": {
        "transaction": {
          "from": "0x0000000000000000000000000000000000000000",
          "to": "0x0000000000000000000000000000000000000001",
          "value": "0x0"
        }
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_sendTransaction",
  "params": {
    "transaction": {
      "from": "0x0000000000000000000000000000000000000000",
      "to": "0x0000000000000000000000000000000000000001",
      "value": "0x0"
    }
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_sendTransaction",
  "params": {
    "transaction": {
      "from": "0x0000000000000000000000000000000000000000",
      "to": "0x0000000000000000000000000000000000000001",
      "value": "0x0"
    }
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x2222222222222222222222222222222222222222222222222222222222222222"
}

eth_sign

POST

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

Sign data using an account managed by the client.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_signrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_sign

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_sign",
    "params": {
      "address": "0x0000000000000000000000000000000000000000",
      "data": "0x68656c6c6f"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_sign",
      "params": {
        "address": "0x0000000000000000000000000000000000000000",
        "data": "0x68656c6c6f"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_sign",
  "params": {
    "address": "0x0000000000000000000000000000000000000000",
    "data": "0x68656c6c6f"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_sign",
  "params": {
    "address": "0x0000000000000000000000000000000000000000",
    "data": "0x68656c6c6f"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0xsignature"
}

eth_signTransaction

POST

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

Sign a transaction without broadcasting it.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_signTransactionrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_signTransaction

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_signTransaction",
    "params": {
      "transaction": {
        "from": "0x0000000000000000000000000000000000000000",
        "to": "0x0000000000000000000000000000000000000001",
        "value": "0x0"
      }
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_signTransaction",
      "params": {
        "transaction": {
          "from": "0x0000000000000000000000000000000000000000",
          "to": "0x0000000000000000000000000000000000000001",
          "value": "0x0"
        }
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_signTransaction",
  "params": {
    "transaction": {
      "from": "0x0000000000000000000000000000000000000000",
      "to": "0x0000000000000000000000000000000000000001",
      "value": "0x0"
    }
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_signTransaction",
  "params": {
    "transaction": {
      "from": "0x0000000000000000000000000000000000000000",
      "to": "0x0000000000000000000000000000000000000001",
      "value": "0x0"
    }
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "raw": "0x",
    "tx": {}
  }
}

eth_syncing

POST

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

Return sync status or sync progress.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_syncingrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_syncing

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_syncing",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_syncing",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_syncing",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_syncing",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": false
}

eth_uninstallFilter

POST

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

Uninstall a filter.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringeth_uninstallFilterrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

eth_uninstallFilter

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_uninstallFilter",
    "params": {
      "filterID": "0x1"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "eth_uninstallFilter",
      "params": {
        "filterID": "0x1"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_uninstallFilter",
  "params": {
    "filterID": "0x1"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_uninstallFilter",
  "params": {
    "filterID": "0x1"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": true
}

net_listening

POST

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

Return whether the client is actively listening for network connections.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringnet_listeningrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

net_listening

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "net_listening",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "net_listening",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "net_listening",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "net_listening",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": true
}

net_peerCount

POST

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

Return the number of connected peers.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringnet_peerCountrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

net_peerCount

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "net_peerCount",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "net_peerCount",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "net_peerCount",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "net_peerCount",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x19"
}

net_version

POST

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

Return the network ID.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringnet_versionrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

net_version

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "net_version",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "net_version",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "net_version",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "net_version",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "43114"
}

web3_clientVersion

POST

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

Return the node client version.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringweb3_clientVersionrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

web3_clientVersion

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "web3_clientVersion",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "web3_clientVersion",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "web3_clientVersion",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "web3_clientVersion",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "avalanche/1.14.2"
}

web3_sha3

POST

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

Return the Keccak-256 hash of the supplied data.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringweb3_sha3required

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

web3_sha3

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "web3_sha3",
    "params": {
      "data": "0x68656c6c6f"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "web3_sha3",
      "params": {
        "data": "0x68656c6c6f"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "web3_sha3",
  "params": {
    "data": "0x68656c6c6f"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "web3_sha3",
  "params": {
    "data": "0x68656c6c6f"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x1c8aff950685c2ed4bc3174f3472287b56d9517b9c948127319a09a7a36deac8"
}

MAINNET / EVM

eth_accounts

Ethereum method - eth_accounts

POST

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

Returns an array of addresses controlled by the client.

Body

application/json

jsonrpcstringrequired

JSON-RPC version identifier

methodstringrequired

Name of the JSON-RPC method

paramsarrayrequired

No parameters are required for this method. This must be an empty array.

idintegerrequired

Unique identifier for the JSON-RPC request

Response

200OK

A list of Ethereum addresses

Authorization

api-keyAuthapiKey in header

Ethereum method - eth_accounts

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_accounts",
    "params": [],
    "id": 1
  }'

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

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_accounts",
  "params": [],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_accounts",
  "params": [],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": [
    "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"
  ]
}

eth_blockNumber

Ethereum method - eth_blockNumber

POST

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

Returns the number of the latest block on the chain in hexadecimal format.

Body

application/json

jsonrpcstringrequired

The JSON-RPC protocol version

methodstringrequired

Name of the method being called

paramsarrayrequired

This method does not take parameters; always send an empty array.

idintegerrequired

A unique ID for the request

Response

200OK

The latest block number

Authorization

api-keyAuthapiKey in header

Ethereum method - eth_blockNumber

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_blockNumber",
    "params": [],
    "id": 1
  }'

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

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_blockNumber",
  "params": [],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_blockNumber",
  "params": [],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x10d4f"
}

eth_call

Ethereum method - eth_call

POST

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

Executes a call to a contract or address and returns the result without broadcasting a transaction.

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsArray<object | string>required

The first object specifies the call transaction object. The second (optional) parameter specifies the block context.

Show child attributes

One of

fromstring

Address the call is sent from (optional)

tostringrequired

Target address for the call (required)

gasstring

Gas provided for the call, as hex

gasPricestring

Gas price in wei, as hex

valuestring

Amount of ETH sent, as hex (optional)

datastring

Compiled contract method call data

(Optional) Integer block number, or the string "latest", "earliest", or "pending".

string

idintegerrequired

Response

200OK

Result of the call

Authorization

api-keyAuthapiKey in header

Ethereum method - eth_call

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_call",
    "params": [
      {
        "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
        "to": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
        "gas": "0x76c0",
        "gasPrice": "0x9184e72a000",
        "value": "0x0",
        "data": "0x70a08231000000000000000000000000a0df350d2637096571f7a701cbc1c5fd..."
      }
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_call",
      "params": [
        {
          "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
          "to": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
          "gas": "0x76c0",
          "gasPrice": "0x9184e72a000",
          "value": "0x0",
          "data": "0x70a08231000000000000000000000000a0df350d2637096571f7a701cbc1c5fd..."
        }
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_call",
  "params": [
    {
      "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
      "to": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
      "gas": "0x76c0",
      "gasPrice": "0x9184e72a000",
      "value": "0x0",
      "data": "0x70a08231000000000000000000000000a0df350d2637096571f7a701cbc1c5fd..."
    }
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_call",
  "params": [
    {
      "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
      "to": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
      "gas": "0x76c0",
      "gasPrice": "0x9184e72a000",
      "value": "0x0",
      "data": "0x70a08231000000000000000000000000a0df350d2637096571f7a701cbc1c5fd..."
    }
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x00000000000000000000000000000000000000000000000000000000000003e8"
}

eth_chainId

Ethereum method - eth_chainId

POST

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

Returns the hexadecimal string of the current chain ID.

Body

application/json

jsonrpcstringrequired

JSON-RPC protocol version

methodstringrequired

Name of the method to call

paramsarrayrequired

This method does not require parameters. Use an empty array.

idintegerrequired

Unique identifier for the request

Response

200OK

Chain ID response

Authorization

api-keyAuthapiKey in header

Ethereum method - eth_chainId

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_chainId",
    "params": [],
    "id": 1
  }'

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

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_chainId",
  "params": [],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_chainId",
  "params": [],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x1"
}

eth_coinbase

POST

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

Returns the Ethereum coinbase address (i.e., the address that receives mining rewards).

Body

application/json

jsonrpcstringrequired

methodstringeth_coinbaserequired

paramsarrayrequired

This method takes no parameters.

idintegerrequired

Response

200OK

JSON-RPC Response with the coinbase address

Authorization

api-keyAuthapiKey in header

eth_coinbase

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_coinbase",
    "params": [],
    "id": 1
  }'

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

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_coinbase",
  "params": [],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_coinbase",
  "params": [],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x0000000000000000000000000000000000000000"
}

eth_estimateGas

Estimate Gas for Transaction

POST

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

Simulates a transaction and returns an estimate of how much gas would be used.

Body

application/json

jsonrpcstringrequired

JSON-RPC protocol version

methodstringrequired

The method name

paramsArray<object | string>required

The transaction call object and an optional block tag.

Show child attributes

One of

fromstring

Address the transaction is sent from (optional)

tostringrequired

Destination address of the call

gasstring

Gas limit provided for execution (optional)

gasPricestring

Gas price in wei (optional)

valuestring

Amount of ETH to send, in hexadecimal wei (optional)

datastring

The compiled input data for the transaction (optional)

Optional block tag (e.g., "latest", "earliest", or a block number)

string

idintegerrequired

Request identifier

Response

200OK

Estimated gas amount

Authorization

api-keyAuthapiKey in header

Estimate Gas for Transaction

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_estimateGas",
    "params": [
      {
        "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
        "to": "0x6b175474e89094c44da98b954eedeac495271d0f",
        "gas": "0x76c0",
        "gasPrice": "0x9184e72a000",
        "value": "0x0",
        "data": "0x70a08231000000000000000000000000a0df350d2637096571f7a701cbc1c5fd"
      }
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_estimateGas",
      "params": [
        {
          "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
          "to": "0x6b175474e89094c44da98b954eedeac495271d0f",
          "gas": "0x76c0",
          "gasPrice": "0x9184e72a000",
          "value": "0x0",
          "data": "0x70a08231000000000000000000000000a0df350d2637096571f7a701cbc1c5fd"
        }
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_estimateGas",
  "params": [
    {
      "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
      "to": "0x6b175474e89094c44da98b954eedeac495271d0f",
      "gas": "0x76c0",
      "gasPrice": "0x9184e72a000",
      "value": "0x0",
      "data": "0x70a08231000000000000000000000000a0df350d2637096571f7a701cbc1c5fd"
    }
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_estimateGas",
  "params": [
    {
      "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
      "to": "0x6b175474e89094c44da98b954eedeac495271d0f",
      "gas": "0x76c0",
      "gasPrice": "0x9184e72a000",
      "value": "0x0",
      "data": "0x70a08231000000000000000000000000a0df350d2637096571f7a701cbc1c5fd"
    }
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x5208"
}

eth_feeHistory

POST

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

Returns fee market information for a range of blocks. This is typically used by wallets and other tools to estimate appropriate gas prices.

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsArray<string | integer | Array<number>>required

Parameters:

blockCount — number of blocks in the requested range.
newestBlock — highest block number in the requested range (can be "latest").
rewardPercentiles — list of percentile values to sample priority fees from each block (optional).

Show child attributes

Any of

string

integer

Array<number>

idintegerrequired

Response

200OK

JSON-RPC Response with fee history data

Authorization

api-keyAuthapiKey in header

eth_feeHistory

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_feeHistory",
    "params": [
      "0x5",
      "latest",
      [
        10,
        50,
        90
      ]
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_feeHistory",
      "params": [
        "0x5",
        "latest",
        [
          10,
          50,
          90
        ]
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_feeHistory",
  "params": [
    "0x5",
    "latest",
    [
      10,
      50,
      90
    ]
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_feeHistory",
  "params": [
    "0x5",
    "latest",
    [
      10,
      50,
      90
    ]
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "oldestBlock": "0x10d4f",
    "baseFeePerGas": [
      "0x1dcd65000"
    ],
    "gasUsedRatio": [
      0.85
    ],
    "reward": [
      [
        "0x59682f00"
      ]
    ]
  }
}

eth_gasPrice

Get Suggested Gas Price

POST

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

Returns the current gas price in wei as a hexadecimal string. This value is a node estimate based on recent blocks and mempool activity.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

JSON-RPC method name

paramsarrayrequired

This method takes an empty array.

idintegerrequired

Request identifier

Response

200OK

Suggested gas price in wei

Authorization

api-keyAuthapiKey in header

Get Suggested Gas Price

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_gasPrice",
    "params": [],
    "id": 1
  }'

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

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_gasPrice",
  "params": [],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_gasPrice",
  "params": [],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x09184e72a000"
}

eth_getBalance

Get ETH Balance of an Address

POST

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

Retrieves the balance (in wei) of a given Ethereum address. You can specify the block parameter to get the balance at a specific block.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

JSON-RPC method name

paramsArray<string | string>required

Array with 2 parameters:

Address (20-byte hex string with '0x' prefix)
Block tag (e.g., 'latest', 'earliest', 'pending', or block number in hex)

Show child attributes

One of

Ethereum address

string

Block tag

string

idintegerrequired

Request ID

Response

200OK

Balance (in wei) as hex string

Authorization

api-keyAuthapiKey in header

Get ETH Balance of an Address

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBalance",
    "params": [
      "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getBalance",
      "params": [
        "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getBalance",
  "params": [
    "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getBalance",
  "params": [
    "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x0234c8a3397aab58"
}

eth_getBlockByHash

Get Block by Hash

POST

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

Returns the block information for the specified block hash. The second parameter indicates whether to return full transaction objects or just transaction hashes.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

JSON-RPC method name

paramsArray<string | boolean>required

Array with 2 parameters:

Block hash (32-byte hex string with '0x' prefix)
Boolean to specify if full transaction objects are returned (true) or only transaction hashes (false)

Show child attributes

One of

Block hash (hex string)

string

Return full transaction objects if true; else return only transaction hashes

boolean

idintegerrequired

Request ID

Response

200OK

Block information

Authorization

api-keyAuthapiKey in header

Get Block by Hash

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockByHash",
    "params": [
      "0x9b559a3d7ee67a0a8bb96ec93c93a0db3f9c66a355a3eb9f3f519c0f26a27c79"
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getBlockByHash",
      "params": [
        "0x9b559a3d7ee67a0a8bb96ec93c93a0db3f9c66a355a3eb9f3f519c0f26a27c79"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getBlockByHash",
  "params": [
    "0x9b559a3d7ee67a0a8bb96ec93c93a0db3f9c66a355a3eb9f3f519c0f26a27c79"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getBlockByHash",
  "params": [
    "0x9b559a3d7ee67a0a8bb96ec93c93a0db3f9c66a355a3eb9f3f519c0f26a27c79"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "number": "0x1b4",
    "hash": "0x9b559a3d7ee67a0a8bb96ec93c93a0db3f9c66a355a3eb9f3f519c0f26a27c79",
    "parentHash": "0x5e8d5f58b0c1be8c3a3d172a41f9f4e35f2f15d5b3347f17a6c11a3aeadf9c10",
    "nonce": "0x0000000000000000",
    "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
    "logsBloom": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
    "stateRoot": "0xd7f8974fb5ac78d9e7a6ccfbcc2fdb5d98a9fdb716e0df485b4d39a5a6f85ebd",
    "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
    "miner": "0x829BD824B016326A401d083B33D092293333A830",
    "difficulty": "0x027f07",
    "totalDifficulty": "0x027f07",
    "extraData": "0x",
    "size": "0x027f07",
    "gasLimit": "0x9f759",
    "gasUsed": "0x9f759",
    "timestamp": "0x54e34e8e",
    "transactions": [
      "0x9f1c04b814a153e1b9f11b60d4e0f9349d07f9251e9b7b60aebb21721c8c07d7"
    ],
    "uncles": [
      "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"
    ]
  }
}

eth_getBlockByNumber

Get Block by Number

POST

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

Returns the block information for the specified block number. The second parameter indicates whether to return full transaction objects or just transaction hashes.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

JSON-RPC method name

paramsArray<string | boolean>required

Array with 2 parameters:

Block number (hex string, e.g., "0x1b4") or special tags ("latest", "earliest", "pending")
Boolean to specify if full transaction objects are returned (true) or only transaction hashes (false)

Show child attributes

One of

Block number as hex string or special tag

string

Return full transaction objects if true; else return only transaction hashes

boolean

idintegerrequired

Request ID

Response

200OK

Block information

Authorization

api-keyAuthapiKey in header

Get Block by Number

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockByNumber",
    "params": [
      "0x1b4"
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getBlockByNumber",
      "params": [
        "0x1b4"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getBlockByNumber",
  "params": [
    "0x1b4"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getBlockByNumber",
  "params": [
    "0x1b4"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "number": "0x1b4",
    "hash": "0x9b559a3d7ee67a0a8bb96ec93c93a0db3f9c66a355a3eb9f3f519c0f26a27c79",
    "parentHash": "0x5e8d5f58b0c1be8c3a3d172a41f9f4e35f2f15d5b3347f17a6c11a3aeadf9c10",
    "nonce": "0x0000000000000000",
    "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
    "logsBloom": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
    "stateRoot": "0xd7f8974fb5ac78d9e7a6ccfbcc2fdb5d98a9fdb716e0df485b4d39a5a6f85ebd",
    "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
    "miner": "0x829BD824B016326A401d083B33D092293333A830",
    "difficulty": "0x027f07",
    "totalDifficulty": "0x027f07",
    "extraData": "0x",
    "size": "0x027f07",
    "gasLimit": "0x9f759",
    "gasUsed": "0x9f759",
    "timestamp": "0x54e34e8e",
    "transactions": [
      "0x9f1c04b814a153e1b9f11b60d4e0f9349d07f9251e9b7b60aebb21721c8c07d7"
    ],
    "uncles": [
      "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"
    ]
  }
}

eth_getBlockReceipts

Get All Transaction Receipts for a Block

POST

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

Returns an array of transaction receipts for every transaction in the block specified by block number or block hash.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

JSON-RPC method name

paramsArray<string>required

One parameter:

Block identifier, which can be either:
- block number as hex string (e.g. "0x10d4f")
- or block hash as hex string (0x-prefixed)

idintegerrequired

Request identifier

Response

200OK

Array of transaction receipts in the block

Authorization

api-keyAuthapiKey in header

Get All Transaction Receipts for a Block

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockReceipts",
    "params": [
      "0x10d4f"
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getBlockReceipts",
      "params": [
        "0x10d4f"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getBlockReceipts",
  "params": [
    "0x10d4f"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getBlockReceipts",
  "params": [
    "0x10d4f"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": [
    {
      "transactionHash": "0x5f4e3b4f5c4c4a6a93c2a3c9d1f47ee7e54b1f4e8a8e0cfd3aabb8a7a8295f7a",
      "transactionIndex": "0x1",
      "blockHash": "0xabc123def456...",
      "blockNumber": "0x10d4f",
      "from": "0x1234567890abcdef1234567890abcdef12345678",
      "to": "0xabcdefabcdefabcdefabcdefabcdefabcdef",
      "cumulativeGasUsed": "0x5208",
      "gasUsed": "0x5208",
      "contractAddress": "0xcontractaddresshere",
      "logs": [
        {
          "removed": false,
          "logIndex": "0x0",
          "transactionIndex": "0x1",
          "transactionHash": "0x5f4e3b4f5c4c4a6a93c2a3c9d1f47ee7e54b1f4e8a8e0cfd3aabb8a7a8295f7a",
          "blockHash": "0xabc123def456...",
          "blockNumber": "0x10d4f",
          "address": "0xcontractaddresshere",
          "data": "0x0000000000000000000000000000000000000000000000000000000000000000",
          "topics": [
            "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
          ]
        }
      ],
      "status": "0x1",
      "root": "0x..."
    }
  ]
}

eth_getBlockTransactionCountByHash

Get Transaction Count by Block Hash

POST

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

Returns the number of transactions contained in the block with the given hash.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

JSON-RPC method name

paramsArray<string>required

Array containing a single parameter:

Block hash as a hex string (32 bytes with 0x prefix)

idintegerrequired

Request ID

Response

200OK

Number of transactions in the block

Authorization

api-keyAuthapiKey in header

Get Transaction Count by Block Hash

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockTransactionCountByHash",
    "params": [
      "0x9b559a3d7ee67a0a8bb96ec93c93a0db3f9c66a355a3eb9f3f519c0f26a27c79"
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getBlockTransactionCountByHash",
      "params": [
        "0x9b559a3d7ee67a0a8bb96ec93c93a0db3f9c66a355a3eb9f3f519c0f26a27c79"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getBlockTransactionCountByHash",
  "params": [
    "0x9b559a3d7ee67a0a8bb96ec93c93a0db3f9c66a355a3eb9f3f519c0f26a27c79"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getBlockTransactionCountByHash",
  "params": [
    "0x9b559a3d7ee67a0a8bb96ec93c93a0db3f9c66a355a3eb9f3f519c0f26a27c79"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x8"
}

eth_getBlockTransactionCountByNumber

Get Transaction Count by Block Number

POST

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

Returns the number of transactions contained in the block with the given block number.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

JSON-RPC method name

paramsArray<string>required

Array containing a single parameter:

Block number as a hex string (e.g. "0x10d4f" for block 69007) or
predefined block tags such as "latest", "earliest", or "pending"

idintegerrequired

Request ID

Response

200OK

Number of transactions in the block

Authorization

api-keyAuthapiKey in header

Get Transaction Count by Block Number

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockTransactionCountByNumber",
    "params": [
      "0x10d4f"
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getBlockTransactionCountByNumber",
      "params": [
        "0x10d4f"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getBlockTransactionCountByNumber",
  "params": [
    "0x10d4f"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getBlockTransactionCountByNumber",
  "params": [
    "0x10d4f"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x8"
}

eth_getCode

Get Contract Bytecode at Address

POST

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

Returns the contract code stored at a given address. If the address is an externally owned account (EOA), it returns "0x".

Body

application/json

jsonrpcstringrequired

JSON-RPC version.

methodstringrequired

JSON-RPC method name.

paramsArray<string>required

Parameters array with two elements:

The address to get the code for (hex string, 0x-prefixed).
The block number or block tag (e.g., "latest", "earliest", "pending").

idintegerrequired

Request identifier.

Response

200OK

Contract bytecode in hex format

Authorization

api-keyAuthapiKey in header

Get Contract Bytecode at Address

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getCode",
    "params": [
      "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
      "latest"
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getCode",
      "params": [
        "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
        "latest"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getCode",
  "params": [
    "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
    "latest"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getCode",
  "params": [
    "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
    "latest"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x6080604052348015600f57600080fd5b5060..."
}

eth_getFilterChanges

Get Filter Changes

POST

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

Returns an array of logs that occurred since the last poll for the specified filter ID. The filter must have been previously created with eth_newFilter or eth_newBlockFilter or eth_newPendingTransactionFilter.

Body

application/json

jsonrpcstringrequired

JSON-RPC version.

methodstringrequired

JSON-RPC method name.

paramsArray<string>required

Parameters array with a single element:

The filter ID (hex string).

idintegerrequired

Request identifier.

Response

200OK

Array of log objects or transaction hashes depending on filter type

Authorization

api-keyAuthapiKey in header

Get Filter Changes

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getFilterChanges",
    "params": [
      "0x16"
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getFilterChanges",
      "params": [
        "0x16"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getFilterChanges",
  "params": [
    "0x16"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getFilterChanges",
  "params": [
    "0x16"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": [
    {
      "address": "0x1234567890abcdef1234567890abcdef12345678",
      "topics": [
        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
      ],
      "data": "0x000000000000000000000000000000000000000000000000000000000000003e8",
      "blockNumber": "0x1b4",
      "transactionHash": "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
      "transactionIndex": "0x0",
      "blockHash": "0xabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcd",
      "logIndex": "0x0",
      "removed": false
    }
  ]
}

eth_getFilterLogs

Get Filter Logs

POST

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

Returns all logs matching a filter with the specified filter ID. The filter must have been previously created with eth_newFilter.

Body

application/json

jsonrpcstringrequired

JSON-RPC version.

methodstringrequired

JSON-RPC method name.

paramsArray<string>required

Parameters array with one element:

The filter ID (hex string).

idintegerrequired

Request identifier.

Response

200OK

Array of log objects matching the filter

Authorization

api-keyAuthapiKey in header

Get Filter Logs

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getFilterLogs",
    "params": [
      "0x16"
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getFilterLogs",
      "params": [
        "0x16"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getFilterLogs",
  "params": [
    "0x16"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getFilterLogs",
  "params": [
    "0x16"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": [
    {
      "address": "0x1234567890abcdef1234567890abcdef12345678",
      "topics": [
        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
      ],
      "data": "0x000000000000000000000000000000000000000000000000000000000000003e8",
      "blockNumber": "0x1b4",
      "transactionHash": "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
      "transactionIndex": "0x0",
      "blockHash": "0xabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcd",
      "logIndex": "0x0",
      "removed": false
    }
  ]
}

eth_getLogs

Get Logs

POST

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

Returns an array of logs that match the filter criteria specified in the params. The filter object supports filtering by block range, addresses, and topics.

Body

application/json

jsonrpcstringrequired

JSON-RPC version.

methodstringrequired

JSON-RPC method name.

paramsArray<object>required

Parameters array with one element: the filter object.

Show child attributes

fromBlockstring

Starting block number (hex string) or "earliest", "latest", "pending".

toBlockstring

Ending block number (hex string) or "earliest", "latest", "pending".

addressstring | Array<string>

Contract address or list of addresses from which logs should originate.

topicsarray

Array of topic filters. Each topic can be a string, null, or an array of strings for OR filtering.

idintegerrequired

Request identifier.

Response

200OK

Array of log objects matching the filter

Authorization

api-keyAuthapiKey in header

Get Logs

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getLogs",
    "params": [
      {
        "fromBlock": "0x1b4",
        "toBlock": "0x1f4",
        "address": "0x1234567890abcdef1234567890abcdef12345678",
        "topics": [
          "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
          null,
          [
            "0x000000000000000000000000a7d9ddbe1f17865597fbd27ec712455208b6b76d",
            "0x000000000000000000000000bb9bc244d798123fde783fcc1c72d3bb8c189413"
          ]
        ]
      }
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getLogs",
      "params": [
        {
          "fromBlock": "0x1b4",
          "toBlock": "0x1f4",
          "address": "0x1234567890abcdef1234567890abcdef12345678",
          "topics": [
            "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
            null,
            [
              "0x000000000000000000000000a7d9ddbe1f17865597fbd27ec712455208b6b76d",
              "0x000000000000000000000000bb9bc244d798123fde783fcc1c72d3bb8c189413"
            ]
          ]
        }
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getLogs",
  "params": [
    {
      "fromBlock": "0x1b4",
      "toBlock": "0x1f4",
      "address": "0x1234567890abcdef1234567890abcdef12345678",
      "topics": [
        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
        null,
        [
          "0x000000000000000000000000a7d9ddbe1f17865597fbd27ec712455208b6b76d",
          "0x000000000000000000000000bb9bc244d798123fde783fcc1c72d3bb8c189413"
        ]
      ]
    }
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getLogs",
  "params": [
    {
      "fromBlock": "0x1b4",
      "toBlock": "0x1f4",
      "address": "0x1234567890abcdef1234567890abcdef12345678",
      "topics": [
        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
        null,
        [
          "0x000000000000000000000000a7d9ddbe1f17865597fbd27ec712455208b6b76d",
          "0x000000000000000000000000bb9bc244d798123fde783fcc1c72d3bb8c189413"
        ]
      ]
    }
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": [
    {
      "address": "0x1234567890abcdef1234567890abcdef12345678",
      "topics": [
        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
      ],
      "data": "0x000000000000000000000000000000000000000000000000000000000000003e8",
      "blockNumber": "0x1b4",
      "transactionHash": "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
      "transactionIndex": "0x0",
      "blockHash": "0xabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcd",
      "logIndex": "0x0",
      "removed": false
    }
  ]
}

eth_getStorageAt

Get Storage At

POST

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

Returns the value stored at position in the storage of the contract at address at the given blockNumber.

Body

application/json

jsonrpcstringrequired

JSON-RPC version.

methodstringrequired

JSON-RPC method name.

paramsArray<string>required

Parameters array:

address: string - Contract address to query storage from.
position: string - Storage slot position (hex string).
block number: string - Block number or keywords ("latest", "earliest", "pending").

idintegerrequired

Request identifier.

Response

200OK

Storage slot value at the specified position

Authorization

api-keyAuthapiKey in header

Get Storage At

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getStorageAt",
    "params": [
      "0x1234567890abcdef1234567890abcdef12345678",
      "0x0",
      "latest"
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getStorageAt",
      "params": [
        "0x1234567890abcdef1234567890abcdef12345678",
        "0x0",
        "latest"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getStorageAt",
  "params": [
    "0x1234567890abcdef1234567890abcdef12345678",
    "0x0",
    "latest"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getStorageAt",
  "params": [
    "0x1234567890abcdef1234567890abcdef12345678",
    "0x0",
    "latest"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x000000000000000000000000000000000000000000000000000000000000000a"
}

eth_getTransactionByBlockHashAndIndex

Get Transaction by Block Hash and Index

POST

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

Retrieves the transaction from a block using the block's hash and the transaction's index position within the block.

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsArray<string>required

Parameters:

blockHash (string): The 32-byte hash of the block.
transactionIndex (string): The transaction index (hex).

idintegerrequired

Response

200OK

A transaction object or null if no transaction was found.

Authorization

api-keyAuthapiKey in header

Get Transaction by Block Hash and Index

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionByBlockHashAndIndex",
    "params": [
      "string"
    ],
    "id": 1
  }'

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

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getTransactionByBlockHashAndIndex",
  "params": [
    "string"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionByBlockHashAndIndex",
  "params": [
    "0xb3b20624a42dffdf1af8e8a6c9b338360585cc309831785f2138e1f9c35a1f09",
    "0x0"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "blockHash": "0xb3b20624a42dffdf1af8e8a6c9b338360585cc309831785f2138e1f9c35a1f09",
    "blockNumber": "0x5daf3b",
    "from": "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
    "gas": "0x5208",
    "gasPrice": "0x4a817c800",
    "hash": "0x3f1c...",
    "input": "0x",
    "nonce": "0x15",
    "to": "0x85h1c2d44cf8531a24b1030f78134677856f7b9f",
    "transactionIndex": "0x0",
    "value": "0x7f110",
    "type": "0x0"
  }
}

eth_getTransactionByBlockNumberAndIndex

Get Transaction by Block Number and Index

POST

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

Returns the information about a transaction using the block number and the transaction index within the block.

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsArray<string>required

Parameters:

Block number in hex format (e.g., "0x5daf3b")
Transaction index in the block (e.g., "0x0")

idintegerrequired

Response

200OK

A transaction object, or null if not found.

Authorization

api-keyAuthapiKey in header

Get Transaction by Block Number and Index

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionByBlockNumberAndIndex",
    "params": [
      "string"
    ],
    "id": 1
  }'

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

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getTransactionByBlockNumberAndIndex",
  "params": [
    "string"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionByBlockNumberAndIndex",
  "params": [
    "0x5daf3b",
    "0x0"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "hash": "0x3f1c7f9e684bbd292f3b849df4c03ff4ffbd83ad2c6cb136a20ee2ebded7df72",
    "nonce": "0x15",
    "blockHash": "0xb3b20624a42dffdf1af8e8a6c9b338360585cc309831785f2138e1f9c35a1f09",
    "blockNumber": "0x5daf3b",
    "transactionIndex": "0x0",
    "from": "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
    "to": "0x85h1c2d44cf8531a24b1030f78134677856f7b9f",
    "value": "0x7f110",
    "gas": "0x5208",
    "gasPrice": "0x4a817c800",
    "input": "0x",
    "type": "0x0"
  }
}

eth_getTransactionByHash

Get transaction by hash

POST

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

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsArray<string>required

Array containing a single transaction hash

idintegerrequired

Response

200OK

Transaction object or null

Authorization

api-keyAuthapiKey in header

Get transaction by hash

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionByHash",
    "params": [
      "0x3f1c7f9e684bbd292f3b849df4c03ff4ffbd83ad2c6cb136a20ee2ebded7df72"
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getTransactionByHash",
      "params": [
        "0x3f1c7f9e684bbd292f3b849df4c03ff4ffbd83ad2c6cb136a20ee2ebded7df72"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getTransactionByHash",
  "params": [
    "0x3f1c7f9e684bbd292f3b849df4c03ff4ffbd83ad2c6cb136a20ee2ebded7df72"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionByHash",
  "params": [
    "0x3f1c7f9e684bbd292f3b849df4c03ff4ffbd83ad2c6cb136a20ee2ebded7df72"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "hash": "0x3f1c7f9e684bbd292f3b849df4c03ff4ffbd83ad2c6cb136a20ee2ebded7df72",
    "nonce": "0x15",
    "blockHash": "0xb3b20624a42dffdf1af8e8a6c9b338360585cc309831785f2138e1f9c35a1f09",
    "blockNumber": "0x5daf3b",
    "transactionIndex": "0x0",
    "from": "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
    "to": "0x85h1c2d44cf8531a24b1030f78134677856f7b9f",
    "value": "0x7f110",
    "gas": "0x5208",
    "gasPrice": "0x4a817c800",
    "input": "0x",
    "type": "0x0"
  }
}

eth_getTransactionCount

Get transaction count (nonce) for address

POST

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

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsArray<string>required

address: The address to check for transaction count.
block: The block parameter (e.g., "latest", "earliest", "pending").

idintegerrequired

Response

200OK

Hex encoded nonce (transaction count)

Authorization

api-keyAuthapiKey in header

Get transaction count (nonce) for address

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionCount",
    "params": [
      "0x742d35cc6634c0532925a3b844bc454e4438f44e",
      "latest"
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getTransactionCount",
      "params": [
        "0x742d35cc6634c0532925a3b844bc454e4438f44e",
        "latest"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getTransactionCount",
  "params": [
    "0x742d35cc6634c0532925a3b844bc454e4438f44e",
    "latest"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionCount",
  "params": [
    "0x742d35cc6634c0532925a3b844bc454e4438f44e",
    "latest"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0xa3"
}

eth_getTransactionReceipt

Get transaction receipt by hash

POST

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

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsArray<string>required

idintegerrequired

Response

200OK

Transaction receipt if mined, otherwise null

Authorization

api-keyAuthapiKey in header

Get transaction receipt by hash

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionReceipt",
    "params": [
      "0x5d1c7b4c8f3474891e1f632f85e7205b6d1a0e0ccbb5cfb1d3a2cf0e9d6f1df7"
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getTransactionReceipt",
      "params": [
        "0x5d1c7b4c8f3474891e1f632f85e7205b6d1a0e0ccbb5cfb1d3a2cf0e9d6f1df7"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getTransactionReceipt",
  "params": [
    "0x5d1c7b4c8f3474891e1f632f85e7205b6d1a0e0ccbb5cfb1d3a2cf0e9d6f1df7"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionReceipt",
  "params": [
    "0x5d1c7b4c8f3474891e1f632f85e7205b6d1a0e0ccbb5cfb1d3a2cf0e9d6f1df7"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "transactionHash": "0x5d1c7b4c8f3474891e1f632f85e7205b6d1a0e0ccbb5cfb1d3a2cf0e9d6f1df7",
    "transactionIndex": "0x0",
    "blockHash": "0x9b559a...",
    "blockNumber": "0x5daf3b",
    "from": "0x742d35cc6634c0532925a3b844bc454e4438f44e",
    "to": "0x53d284357ec70ce289d6d64134dfac8e511c8a3d",
    "cumulativeGasUsed": "0x5208",
    "gasUsed": "0x5208",
    "contractAddress": null,
    "logs": [],
    "logsBloom": "0x000...",
    "status": "0x1"
  }
}

eth_getUncleByBlockHashAndIndex

Get uncle block by block hash and index

POST

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

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsArray<string>required

blockHash: 32-byte block hash
index: the uncle index as hex (e.g., "0x0" for the first uncle)

idintegerrequired

Response

200OK

Uncle block object or null

Authorization

api-keyAuthapiKey in header

Get uncle block by block hash and index

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getUncleByBlockHashAndIndex",
    "params": [
      "0x9b559a28a108e15b95e4e30b8a4a1e301dcdb4f3f7f0f79fd859f568f9d9ff34",
      "0x0"
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getUncleByBlockHashAndIndex",
      "params": [
        "0x9b559a28a108e15b95e4e30b8a4a1e301dcdb4f3f7f0f79fd859f568f9d9ff34",
        "0x0"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getUncleByBlockHashAndIndex",
  "params": [
    "0x9b559a28a108e15b95e4e30b8a4a1e301dcdb4f3f7f0f79fd859f568f9d9ff34",
    "0x0"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getUncleByBlockHashAndIndex",
  "params": [
    "0x9b559a28a108e15b95e4e30b8a4a1e301dcdb4f3f7f0f79fd859f568f9d9ff34",
    "0x0"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "number": "0x5daf3c",
    "hash": "0xabc123...",
    "parentHash": "0xdef456...",
    "miner": "0x1234567890abcdef1234567890abcdef12345678",
    "difficulty": "0x3e8",
    "totalDifficulty": "0x1d4c",
    "extraData": "0x",
    "size": "0x220",
    "gasLimit": "0x7a1200",
    "gasUsed": "0x5208",
    "timestamp": "0x5bad55",
    "transactions": []
  }
}

eth_getUncleByBlockNumberAndIndex

Get uncle block by block number and index

POST

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

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsArray<string>required

blockNumber: The block number as hex string (e.g., "0x10fb78"), or "latest", "earliest", "pending".
index: The uncle index as hex (e.g., "0x0" for the first uncle).

idintegerrequired

Response

200OK

Uncle block object or null

Authorization

api-keyAuthapiKey in header

Get uncle block by block number and index

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getUncleByBlockNumberAndIndex",
    "params": [
      "0x5daf3b",
      "0x0"
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getUncleByBlockNumberAndIndex",
      "params": [
        "0x5daf3b",
        "0x0"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getUncleByBlockNumberAndIndex",
  "params": [
    "0x5daf3b",
    "0x0"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getUncleByBlockNumberAndIndex",
  "params": [
    "0x5daf3b",
    "0x0"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "number": "0x5daf3c",
    "hash": "0xabc123abc123abc123abc123abc123abc123abc123abc123abc123abc123abc1",
    "parentHash": "0xdef456def456def456def456def456def456def456def456def456def456def4",
    "miner": "0x1234567890abcdef1234567890abcdef12345678",
    "difficulty": "0x3e8",
    "totalDifficulty": "0x1d4c",
    "extraData": "0x",
    "size": "0x220",
    "gasLimit": "0x7a1200",
    "gasUsed": "0x5208",
    "timestamp": "0x5bad55",
    "transactions": []
  }
}

eth_getUncleCountByBlockHash

Get the number of uncle blocks by block hash

POST

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

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsArray<string>required

An array containing the block hash.

idintegerrequired

Response

200OK

Number of uncles in the block

Authorization

api-keyAuthapiKey in header

Get the number of uncle blocks by block hash

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getUncleCountByBlockHash",
    "params": [
      "0x9b559a937406429b662b9bd5b2be3c7a2ed36b5a0dbcf0d07a987f695705daec"
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getUncleCountByBlockHash",
      "params": [
        "0x9b559a937406429b662b9bd5b2be3c7a2ed36b5a0dbcf0d07a987f695705daec"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getUncleCountByBlockHash",
  "params": [
    "0x9b559a937406429b662b9bd5b2be3c7a2ed36b5a0dbcf0d07a987f695705daec"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getUncleCountByBlockHash",
  "params": [
    "0x9b559a937406429b662b9bd5b2be3c7a2ed36b5a0dbcf0d07a987f695705daec"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x1"
}

eth_getUncleCountByBlockNumber

Get the number of uncle blocks by block number

POST

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

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsArray<string>required

An array containing the block number as a hex string.

idintegerrequired

Response

200OK

Number of uncle blocks in the block

Authorization

api-keyAuthapiKey in header

Get the number of uncle blocks by block number

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getUncleCountByBlockNumber",
    "params": [
      "0x10d4f"
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getUncleCountByBlockNumber",
      "params": [
        "0x10d4f"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getUncleCountByBlockNumber",
  "params": [
    "0x10d4f"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getUncleCountByBlockNumber",
  "params": [
    "0x10d4f"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x2"
}

eth_hashrate

POST

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

Returns the current mining hashrate reported by the client.

Body

application/json

jsonrpcstringrequired

methodstringeth_hashraterequired

paramsarrayrequired

This method takes no parameters.

idintegerrequired

Response

200OK

JSON-RPC response with the current mining hashrate

Authorization

api-keyAuthapiKey in header

eth_hashrate

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_hashrate",
    "params": [],
    "id": 1
  }'

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

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_hashrate",
  "params": [],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_hashrate",
  "params": [],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x3b9aca00"
}

eth_maxPriorityFeePerGas

Get recommended maxPriorityFeePerGas value

POST

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

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsarrayrequired

No parameters are required.

idintegerrequired

Response

200OK

Returns the suggested maxPriorityFeePerGas value

Authorization

api-keyAuthapiKey in header

Get recommended maxPriorityFeePerGas value

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_maxPriorityFeePerGas",
    "params": [],
    "id": 1
  }'

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

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_maxPriorityFeePerGas",
  "params": [],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_maxPriorityFeePerGas",
  "params": [],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x3b9aca00"
}

eth_mining

POST

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

Checks whether the Ethereum client is actively mining.

Body

application/json

jsonrpcstringrequired

methodstringeth_miningrequired

paramsarrayrequired

This method does not accept parameters.

idintegerrequired

Response

200OK

JSON-RPC Response indicating mining status

Authorization

api-keyAuthapiKey in header

eth_mining

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_mining",
    "params": [],
    "id": 1
  }'

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

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_mining",
  "params": [],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_mining",
  "params": [],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": false
}

eth_newBlockFilter

Create a new block filter

POST

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

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsArray<any>required

This method does not require any parameters.

idintegerrequired

Response

200OK

Filter ID created successfully

Authorization

api-keyAuthapiKey in header

Create a new block filter

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_newBlockFilter",
    "params": [],
    "id": 1
  }'

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

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_newBlockFilter",
  "params": [],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_newBlockFilter",
  "params": [],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x16"
}

eth_newFilter

Create a new log filter

POST

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

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsArray<object>required

Array with one object describing the filter options.

Show child attributes

fromBlockstring

Starting block number or tag ("latest", "earliest", "pending").

toBlockstring

Ending block number or tag.

addressstring | Array<string> | null

topicsArray<string | Array<string>> | null

Array of topic filters. Topics are 32-byte hashes identifying events.

Show child attributes

One of

string

Array<string>

idintegerrequired

Response

200OK

Filter ID created successfully

Authorization

api-keyAuthapiKey in header

Create a new log filter

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_newFilter",
    "params": [
      {
        "fromBlock": "latest",
        "toBlock": "latest",
        "address": "0x1234567890abcdef1234567890abcdef12345678",
        "topics": [
          "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
        ]
      }
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_newFilter",
      "params": [
        {
          "fromBlock": "latest",
          "toBlock": "latest",
          "address": "0x1234567890abcdef1234567890abcdef12345678",
          "topics": [
            "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
          ]
        }
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_newFilter",
  "params": [
    {
      "fromBlock": "latest",
      "toBlock": "latest",
      "address": "0x1234567890abcdef1234567890abcdef12345678",
      "topics": [
        "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
      ]
    }
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_newFilter",
  "params": [
    {
      "fromBlock": "latest",
      "toBlock": "latest",
      "address": "0x1234567890abcdef1234567890abcdef12345678",
      "topics": [
        "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
      ]
    }
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x16"
}

eth_newPendingTransactionFilter

Create a filter for pending transactions

POST

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

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

JSON-RPC method name

paramsArray<any>required

No parameters required for this method

idintegerrequired

Request identifier

Response

200OK

Filter ID created successfully

Authorization

api-keyAuthapiKey in header

Create a filter for pending transactions

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_newPendingTransactionFilter",
    "params": [],
    "id": 1
  }'

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

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_newPendingTransactionFilter",
  "params": [],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_newPendingTransactionFilter",
  "params": [],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x16"
}

eth_sendRawTransaction

Send a raw signed transaction

POST

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

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

Method name

paramsArray<string>required

Array containing a single signed transaction data (hex string)

idintegerrequired

Request ID

Response

200OK

Transaction successfully sent

Authorization

api-keyAuthapiKey in header

Send a raw signed transaction

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_sendRawTransaction",
    "params": [
      "0xf86b808504a817c800825208940000000000000000000000000000000000000000880de0b6b3a76400008026a0980..."
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_sendRawTransaction",
      "params": [
        "0xf86b808504a817c800825208940000000000000000000000000000000000000000880de0b6b3a76400008026a0980..."
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_sendRawTransaction",
  "params": [
    "0xf86b808504a817c800825208940000000000000000000000000000000000000000880de0b6b3a76400008026a0980..."
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_sendRawTransaction",
  "params": [
    "0xf86b808504a817c800825208940000000000000000000000000000000000000000880de0b6b3a76400008026a0c6a6..."
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x7f8a08576b8474e17e8311c2732029232892d450bfdc30816ffb133c2f8e3f1a"
}

eth_sendTransaction

Send a transaction using node-managed account

POST

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

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsArray<object>required

Transaction object

Show child attributes

fromstring

Address the transaction is sent from

tostring

Address the transaction is directed to

gasstring

Gas provided for the transaction (hex)

gasPricestring

Gas price in wei (hex)

valuestring

Value sent with the transaction in wei (hex)

datastring

(Optional) Data for contract interaction

idintegerrequired

Response

200OK

Transaction successfully sent

Authorization

api-keyAuthapiKey in header

Send a transaction using node-managed account

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_sendTransaction",
    "params": [
      {
        "from": "0x6A0bF1017C6e6Dd9D2BA447E2AAd951F13F7F7C3",
        "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
        "gas": "0x5208",
        "gasPrice": "0x3b9aca00",
        "value": "0x16345785d8a0000",
        "data": "0x"
      }
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_sendTransaction",
      "params": [
        {
          "from": "0x6A0bF1017C6e6Dd9D2BA447E2AAd951F13F7F7C3",
          "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
          "gas": "0x5208",
          "gasPrice": "0x3b9aca00",
          "value": "0x16345785d8a0000",
          "data": "0x"
        }
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_sendTransaction",
  "params": [
    {
      "from": "0x6A0bF1017C6e6Dd9D2BA447E2AAd951F13F7F7C3",
      "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
      "gas": "0x5208",
      "gasPrice": "0x3b9aca00",
      "value": "0x16345785d8a0000",
      "data": "0x"
    }
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_sendTransaction",
  "params": [
    {
      "from": "0x6A0bF1017C6e6Dd9D2BA447E2AAd951F13F7F7C3",
      "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
      "gas": "0x5208",
      "gasPrice": "0x3b9aca00",
      "value": "0x16345785d8a0000",
      "data": "0x"
    }
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x5f5c67a3120bb6e038f8460cb2e8393dcd1704b2e1ef7689e3ec6b867a2bcae4"
}

eth_sign

Sign arbitrary data using eth_sign

POST

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

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsArray<string>required

[address, data]

address: The account that will sign the data
data: The data to be signed (must be a hex string)

idintegerrequired

Response

200OK

Returns the signature of the message

Authorization

api-keyAuthapiKey in header

Sign arbitrary data using eth_sign

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_sign",
    "params": [
      "string"
    ],
    "id": 1
  }'

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

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_sign",
  "params": [
    "string"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_sign",
  "params": [
    "0x6A0bF1017C6e6Dd9D2BA447E2AAd951F13F7F7C3",
    "0x68656c6c6f20776f726c64"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x2c6401ff899fb4b2f7e118b9ff05ebc1428fc2e3a08779b589f1de94c8e56064d056f3d23b32bcb0e11aaee71a51bd8b3a7b361a3b4998b061"
}

eth_signTransaction

POST

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

Signs a transaction locally with the private key of the specified account.

Body

application/json

jsonrpcstringrequired

methodstringeth_signTransactionrequired

paramsArray<object>required

Array with a single object representing the transaction to sign.

Show child attributes

fromstringrequired

The address of the account that will sign the transaction.

tostring

The destination address of the transaction.

gasstring

Gas limit for the transaction, as a hex string.

gasPricestring

Gas price in wei, as a hex string.

valuestring

Amount of wei to send, as a hex string.

datastring

Data payload of the transaction, hex encoded.

noncestring

Nonce of the transaction, as a hex string.

chainIdinteger

The chain ID to protect against replay attacks.

idintegerrequired

Response

200OK

JSON-RPC response with the signed transaction data

Authorization

api-keyAuthapiKey in header

eth_signTransaction

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_signTransaction",
    "params": [
      {
        "from": "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
        "to": "0x85a3d76e3a6a4b16b5b442c1b11a03bdcc0a9f30",
        "gas": "0x5208",
        "gasPrice": "0x4a817c800",
        "value": "0xde0b6b3a7640000",
        "data": "0x",
        "nonce": "0x1",
        "chainId": 1
      }
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_signTransaction",
      "params": [
        {
          "from": "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
          "to": "0x85a3d76e3a6a4b16b5b442c1b11a03bdcc0a9f30",
          "gas": "0x5208",
          "gasPrice": "0x4a817c800",
          "value": "0xde0b6b3a7640000",
          "data": "0x",
          "nonce": "0x1",
          "chainId": 1
        }
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_signTransaction",
  "params": [
    {
      "from": "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
      "to": "0x85a3d76e3a6a4b16b5b442c1b11a03bdcc0a9f30",
      "gas": "0x5208",
      "gasPrice": "0x4a817c800",
      "value": "0xde0b6b3a7640000",
      "data": "0x",
      "nonce": "0x1",
      "chainId": 1
    }
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_signTransaction",
  "params": [
    {
      "from": "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
      "to": "0x85a3d76e3a6a4b16b5b442c1b11a03bdcc0a9f30",
      "gas": "0x5208",
      "gasPrice": "0x4a817c800",
      "value": "0xde0b6b3a7640000",
      "data": "0x",
      "nonce": "0x1",
      "chainId": 1
    }
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0xf86c808504a817c80082520894b60e8dd61c5d32be8058bb8eb970870f072331550880de0b6b3a76400008025a08b5a9e4f3e93096d046a9e4d4f28e0e2aab034c8998a2a4015304e80a40338c5a047d092f3246c4e11d995cbca7ed8a47aaf3dfeff8b6af33d57f4caba1c88b52c7"
}

eth_syncing

Check if node is syncing

POST

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

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsarrayrequired

Must be an empty array.

idintegerrequired

Response

200OK

Returns sync status object or false

Authorization

api-keyAuthapiKey in header

Check if node is syncing

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_syncing",
    "params": [],
    "id": 1
  }'

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

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_syncing",
  "params": [],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_syncing",
  "params": [],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": false
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "startingBlock": "0x384",
    "currentBlock": "0x386",
    "highestBlock": "0x454"
  }
}

eth_uninstallFilter

Uninstall an existing filter

POST

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

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsArray<string>required

idintegerrequired

Response

200OK

Success or failure of the uninstall operation

Authorization

api-keyAuthapiKey in header

Uninstall an existing filter

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_uninstallFilter",
    "params": [
      "0x16"
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_uninstallFilter",
      "params": [
        "0x16"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_uninstallFilter",
  "params": [
    "0x16"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_uninstallFilter",
  "params": [
    "0x16"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": true
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": false
}

net_listening

POST

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

Checks if the client is listening for network connections.

Body

application/json

jsonrpcstringrequired

methodstringnet_listeningrequired

paramsarrayrequired

This method takes no parameters.

idintegerrequired

Response

200OK

JSON-RPC response with listening status

Authorization

api-keyAuthapiKey in header

net_listening

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "net_listening",
    "params": [],
    "id": 1
  }'

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

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "net_listening",
  "params": [],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "net_listening",
  "params": [],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": true
}

net_peerCount

POST

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

Returns the number of peers currently connected to the client.

Body

application/json

jsonrpcstringrequired

methodstringnet_peerCountrequired

paramsarrayrequired

This method takes no parameters.

idintegerrequired

Response

200OK

JSON-RPC response with the number of connected peers

Authorization

api-keyAuthapiKey in header

net_peerCount

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "net_peerCount",
    "params": [],
    "id": 1
  }'

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

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "net_peerCount",
  "params": [],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "net_peerCount",
  "params": [],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x8"
}

net_version

POST

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

Returns the current network ID of the Ethereum client.

Body

application/json

jsonrpcstringrequired

methodstringnet_versionrequired

paramsarrayrequired

This method takes no parameters.

idintegerrequired

Response

200OK

JSON-RPC response with the current network ID

Authorization

api-keyAuthapiKey in header

net_version

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "net_version",
    "params": [],
    "id": 1
  }'

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

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "net_version",
  "params": [],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "net_version",
  "params": [],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "1"
}

web3_clientVersion

POST

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

Returns the current Ethereum client version.

Body

application/json

jsonrpcstringrequired

methodstringweb3_clientVersionrequired

paramsarrayrequired

This method takes no parameters.

idintegerrequired

Response

200OK

JSON-RPC response with the client version string

Authorization

api-keyAuthapiKey in header

web3_clientVersion

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "web3_clientVersion",
    "params": [],
    "id": 1
  }'

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

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "web3_clientVersion",
  "params": [],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "web3_clientVersion",
  "params": [],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "Geth/v1.10.8-stable-26675454/linux-amd64/go1.16.6"
}

web3_sha3

POST

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

Computes the Keccak-256 (SHA-3) hash of the given hex-encoded data.

Body

application/json

jsonrpcstringrequired

methodstringweb3_sha3required

paramsArray<string>required

Array containing a single hex-encoded data string to hash.

idintegerrequired

Response

200OK

JSON-RPC response with the Keccak-256 hash of the input data

Authorization

api-keyAuthapiKey in header

web3_sha3

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "web3_sha3",
    "params": [
      "0x68656c6c6f"
    ],
    "id": 1
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "web3_sha3",
      "params": [
        "0x68656c6c6f"
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "web3_sha3",
  "params": [
    "0x68656c6c6f"
  ],
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "web3_sha3",
  "params": [
    "0x68656c6c6f"
  ],
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x5d41402abc4b2a76b9719d911017c592"
}

MAINNET / Index

Index

index.getContainerByID

POST

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

Get an indexed container by ID.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringindex.getContainerByIDrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

index.getContainerByID

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "index.getContainerByID",
    "params": {
      "id": "6fXf5hncR8LXvwtM8iezFQBpK5cubV6y1dWgpJCcNyzGB1EzY",
      "encoding": "hex"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "index.getContainerByID",
      "params": {
        "id": "6fXf5hncR8LXvwtM8iezFQBpK5cubV6y1dWgpJCcNyzGB1EzY",
        "encoding": "hex"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "index.getContainerByID",
  "params": {
    "id": "6fXf5hncR8LXvwtM8iezFQBpK5cubV6y1dWgpJCcNyzGB1EzY",
    "encoding": "hex"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "index.getContainerByID",
  "params": {
    "id": "6fXf5hncR8LXvwtM8iezFQBpK5cubV6y1dWgpJCcNyzGB1EzY",
    "encoding": "hex"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "id": "6fXf5hncR8LXvwtM8iezFQBpK5cubV6y1dWgpJCcNyzGB1EzY",
    "bytes": "0x0000",
    "timestamp": "2021-04-02T15:34:00.262979-07:00",
    "encoding": "hex",
    "index": "0"
  }
}

index.getContainerByIndex

POST

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

Get an indexed container by its index.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringindex.getContainerByIndexrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

index.getContainerByIndex

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "index.getContainerByIndex",
    "params": {
      "index": "0",
      "encoding": "hex"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "index.getContainerByIndex",
      "params": {
        "index": "0",
        "encoding": "hex"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "index.getContainerByIndex",
  "params": {
    "index": "0",
    "encoding": "hex"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "index.getContainerByIndex",
  "params": {
    "index": "0",
    "encoding": "hex"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "id": "6fXf5hncR8LXvwtM8iezFQBpK5cubV6y1dWgpJCcNyzGB1EzY",
    "bytes": "0x0000",
    "timestamp": "2021-04-02T15:34:00.262979-07:00",
    "encoding": "hex",
    "index": "0"
  }
}

index.getContainerRange

POST

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

Get a range of indexed containers.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringindex.getContainerRangerequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

index.getContainerRange

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "index.getContainerRange",
    "params": {
      "startIndex": "0",
      "numToFetch": "10",
      "encoding": "hex"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "index.getContainerRange",
      "params": {
        "startIndex": "0",
        "numToFetch": "10",
        "encoding": "hex"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "index.getContainerRange",
  "params": {
    "startIndex": "0",
    "numToFetch": "10",
    "encoding": "hex"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "index.getContainerRange",
  "params": {
    "startIndex": "0",
    "numToFetch": "10",
    "encoding": "hex"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "containers": []
  }
}

index.getIndex

POST

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

Get the index assigned to a container.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringindex.getIndexrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

index.getIndex

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "index.getIndex",
    "params": {
      "containerID": "6fXf5hncR8LXvwtM8iezFQBpK5cubV6y1dWgpJCcNyzGB1EzY"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "index.getIndex",
      "params": {
        "containerID": "6fXf5hncR8LXvwtM8iezFQBpK5cubV6y1dWgpJCcNyzGB1EzY"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "index.getIndex",
  "params": {
    "containerID": "6fXf5hncR8LXvwtM8iezFQBpK5cubV6y1dWgpJCcNyzGB1EzY"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "index.getIndex",
  "params": {
    "containerID": "6fXf5hncR8LXvwtM8iezFQBpK5cubV6y1dWgpJCcNyzGB1EzY"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "index": "0"
  }
}

index.getLastAccepted

POST

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

Get the last accepted indexed container.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringindex.getLastAcceptedrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

index.getLastAccepted

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "index.getLastAccepted",
    "params": {
      "encoding": "hex"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "index.getLastAccepted",
      "params": {
        "encoding": "hex"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "index.getLastAccepted",
  "params": {
    "encoding": "hex"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "index.getLastAccepted",
  "params": {
    "encoding": "hex"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "id": "6fXf5hncR8LXvwtM8iezFQBpK5cubV6y1dWgpJCcNyzGB1EzY",
    "bytes": "0x0000",
    "timestamp": "2021-04-02T15:34:00.262979-07:00",
    "encoding": "hex",
    "index": "0"
  }
}

MAINNET / P-Chain

P-Chain

platform.getAllValidatorsAt

POST

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

Get validators for all subnets at a P-Chain height.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getAllValidatorsAtrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getAllValidatorsAt

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getAllValidatorsAt",
    "params": {
      "height": "proposed"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getAllValidatorsAt",
      "params": {
        "height": "proposed"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getAllValidatorsAt",
  "params": {
    "height": "proposed"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getAllValidatorsAt",
  "params": {
    "height": "proposed"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "subnets": {}
  }
}

platform.getBalance

POST

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

Get the balance of AVAX controlled by the specified addresses.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getBalancerequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getBalance

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getBalance",
    "params": {
      "addresses": [
        "P-avax1..."
      ]
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getBalance",
      "params": {
        "addresses": [
          "P-avax1..."
        ]
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getBalance",
  "params": {
    "addresses": [
      "P-avax1..."
    ]
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getBalance",
  "params": {
    "addresses": [
      "P-avax1..."
    ]
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "balance": "30000000000000000",
    "unlocked": "20000000000000000",
    "lockedStakeable": "10000000000000000",
    "lockedNotStakeable": "0",
    "utxoIDs": []
  }
}

platform.getBlock

POST

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

Get a P-Chain block by its ID.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getBlockrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getBlock

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getBlock",
    "params": {
      "blockID": "d7WYmb8VeZNHsny3EJCwMm6QA37s1EHwMxw1Y71V3FqPZ5EFG",
      "encoding": "json"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getBlock",
      "params": {
        "blockID": "d7WYmb8VeZNHsny3EJCwMm6QA37s1EHwMxw1Y71V3FqPZ5EFG",
        "encoding": "json"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getBlock",
  "params": {
    "blockID": "d7WYmb8VeZNHsny3EJCwMm6QA37s1EHwMxw1Y71V3FqPZ5EFG",
    "encoding": "json"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getBlock",
  "params": {
    "blockID": "d7WYmb8VeZNHsny3EJCwMm6QA37s1EHwMxw1Y71V3FqPZ5EFG",
    "encoding": "json"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "block": {
      "parentID": "5615di9ytxujackzaXNrVuWQy5y8Yrt8chPCscMr5Ku9YxJ1S",
      "height": 1000001,
      "txs": []
    },
    "encoding": "json"
  }
}

platform.getBlockByHeight

POST

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

Get a P-Chain block by height.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getBlockByHeightrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getBlockByHeight

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getBlockByHeight",
    "params": {
      "height": "1000000",
      "encoding": "json"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getBlockByHeight",
      "params": {
        "height": "1000000",
        "encoding": "json"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getBlockByHeight",
  "params": {
    "height": "1000000",
    "encoding": "json"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getBlockByHeight",
  "params": {
    "height": "1000000",
    "encoding": "json"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "block": {
      "height": 1000000,
      "txs": []
    },
    "encoding": "json"
  }
}

platform.getBlockchains

POST

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

Get the blockchains that exist on the Avalanche network.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getBlockchainsrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getBlockchains

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getBlockchains",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getBlockchains",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getBlockchains",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getBlockchains",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "blockchains": [
      {
        "id": "2q9e4r...",
        "name": "C-Chain",
        "subnetID": "11111111111111111111111111111111LpoYY",
        "vmID": "mgj786NP7uDwBCcq6YwThhaN8FLyybkfz13YWoC6YV7ga6g9"
      }
    ]
  }
}

platform.getCurrentSupply

POST

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

Get the current supply of the staking asset for a subnet.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getCurrentSupplyrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getCurrentSupply

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getCurrentSupply",
    "params": {
      "subnetID": "11111111111111111111111111111111LpoYY"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getCurrentSupply",
      "params": {
        "subnetID": "11111111111111111111111111111111LpoYY"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getCurrentSupply",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getCurrentSupply",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "supply": "431000000000000000",
    "height": "1234567"
  }
}

platform.getCurrentValidators

POST

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

Get the current validators of a subnet or the Primary Network.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getCurrentValidatorsrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getCurrentValidators

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getCurrentValidators",
    "params": {
      "subnetID": "11111111111111111111111111111111LpoYY",
      "nodeIDs": []
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getCurrentValidators",
      "params": {
        "subnetID": "11111111111111111111111111111111LpoYY",
        "nodeIDs": []
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getCurrentValidators",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY",
    "nodeIDs": []
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getCurrentValidators",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY",
    "nodeIDs": []
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "validators": []
  }
}

platform.getFeeConfig

POST

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

Return the P-Chain dynamic fee configuration.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getFeeConfigrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getFeeConfig

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getFeeConfig",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getFeeConfig",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getFeeConfig",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getFeeConfig",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "weights": {
      "bandwidth": "1",
      "dbRead": "1",
      "dbWrite": "1",
      "compute": "1"
    },
    "maxCapacity": "1000000",
    "maxPerSecond": "100000",
    "targetPerSecond": "50000",
    "minPrice": "1",
    "excessConversionConstant": "1000"
  }
}

platform.getFeeState

POST

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

Return the current P-Chain fee state.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getFeeStaterequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getFeeState

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getFeeState",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getFeeState",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getFeeState",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getFeeState",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "capacity": "1000000",
    "excess": "0",
    "price": "1",
    "timestamp": "2026-07-30T12:00:00Z"
  }
}

platform.getHeight

POST

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

Get the height of the last accepted P-Chain block.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getHeightrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getHeight

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getHeight",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getHeight",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getHeight",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getHeight",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "height": "1234567"
  }
}

platform.getL1Validator

POST

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

Get information about an L1 validator.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getL1Validatorrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getL1Validator

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getL1Validator",
    "params": {
      "validationID": "2wTscvX3JUsMbZHFRd9t8Ywz2q9j2BmETg8cTvgUHgawjbSvZX"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getL1Validator",
      "params": {
        "validationID": "2wTscvX3JUsMbZHFRd9t8Ywz2q9j2BmETg8cTvgUHgawjbSvZX"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getL1Validator",
  "params": {
    "validationID": "2wTscvX3JUsMbZHFRd9t8Ywz2q9j2BmETg8cTvgUHgawjbSvZX"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getL1Validator",
  "params": {
    "validationID": "2wTscvX3JUsMbZHFRd9t8Ywz2q9j2BmETg8cTvgUHgawjbSvZX"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "validationID": "2wTscvX3JUsMbZHFRd9t8Ywz2q9j2BmETg8cTvgUHgawjbSvZX",
    "nodeID": "NodeID-5mb46qkSBj81k9g9e4VFjGGSbaaSLFRzD",
    "weight": "20"
  }
}

platform.getMaxStakeAmount

POST

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

Get the maximum amount that may be staked on a validator during a time range.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getMaxStakeAmountrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getMaxStakeAmount

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getMaxStakeAmount",
    "params": {
      "subnetID": "11111111111111111111111111111111LpoYY",
      "nodeID": "NodeID-5mb46qkSBj81k9g9e4VFjGGSbaaSLFRzD",
      "startTime": "1730000000",
      "endTime": "1731000000"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getMaxStakeAmount",
      "params": {
        "subnetID": "11111111111111111111111111111111LpoYY",
        "nodeID": "NodeID-5mb46qkSBj81k9g9e4VFjGGSbaaSLFRzD",
        "startTime": "1730000000",
        "endTime": "1731000000"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getMaxStakeAmount",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY",
    "nodeID": "NodeID-5mb46qkSBj81k9g9e4VFjGGSbaaSLFRzD",
    "startTime": "1730000000",
    "endTime": "1731000000"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getMaxStakeAmount",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY",
    "nodeID": "NodeID-5mb46qkSBj81k9g9e4VFjGGSbaaSLFRzD",
    "startTime": "1730000000",
    "endTime": "1731000000"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "amount": "3000000000000"
  }
}

platform.getMinStake

POST

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

Get the minimum validator and delegator stake amounts.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getMinStakerequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getMinStake

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getMinStake",
    "params": {
      "subnetID": "11111111111111111111111111111111LpoYY"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getMinStake",
      "params": {
        "subnetID": "11111111111111111111111111111111LpoYY"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getMinStake",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getMinStake",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "minValidatorStake": "2000000000000",
    "minDelegatorStake": "25000000000"
  }
}

platform.getPendingValidators

POST

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

Get pending validators and delegators.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getPendingValidatorsrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getPendingValidators

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getPendingValidators",
    "params": {
      "subnetID": "11111111111111111111111111111111LpoYY",
      "nodeIDs": []
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getPendingValidators",
      "params": {
        "subnetID": "11111111111111111111111111111111LpoYY",
        "nodeIDs": []
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getPendingValidators",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY",
    "nodeIDs": []
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getPendingValidators",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY",
    "nodeIDs": []
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "validators": [],
    "delegators": []
  }
}

platform.getProposedHeight

POST

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

Get the P-Chain height proposed by the ProposerVM.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getProposedHeightrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getProposedHeight

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getProposedHeight",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getProposedHeight",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getProposedHeight",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getProposedHeight",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "height": "1234568"
  }
}

platform.getRewardUTXOs

POST

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

Get UTXOs rewarded after a staking or delegation period ended.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getRewardUTXOsrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getRewardUTXOs

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getRewardUTXOs",
    "params": {
      "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9",
      "encoding": "hex"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getRewardUTXOs",
      "params": {
        "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9",
        "encoding": "hex"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getRewardUTXOs",
  "params": {
    "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9",
    "encoding": "hex"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getRewardUTXOs",
  "params": {
    "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9",
    "encoding": "hex"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "numFetched": "1",
    "utxos": [
      "0x0000"
    ],
    "encoding": "hex"
  }
}

platform.getStake

POST

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

Get the amount staked by the specified addresses.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getStakerequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getStake

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getStake",
    "params": {
      "addresses": [
        "P-avax1pmgmagjcljjzuz2ve339dx82khm7q8getlegte"
      ],
      "validatorsOnly": true
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getStake",
      "params": {
        "addresses": [
          "P-avax1pmgmagjcljjzuz2ve339dx82khm7q8getlegte"
        ],
        "validatorsOnly": true
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getStake",
  "params": {
    "addresses": [
      "P-avax1pmgmagjcljjzuz2ve339dx82khm7q8getlegte"
    ],
    "validatorsOnly": True
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getStake",
  "params": {
    "addresses": [
      "P-avax1pmgmagjcljjzuz2ve339dx82khm7q8getlegte"
    ],
    "validatorsOnly": true
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "staked": "6500000000000",
    "stakeds": {},
    "stakedOutputs": [],
    "encoding": "hex"
  }
}

platform.getStakingAssetID

POST

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

Get the staking asset ID for a subnet.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getStakingAssetIDrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getStakingAssetID

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getStakingAssetID",
    "params": {
      "subnetID": "11111111111111111111111111111111LpoYY"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getStakingAssetID",
      "params": {
        "subnetID": "11111111111111111111111111111111LpoYY"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getStakingAssetID",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getStakingAssetID",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "assetID": "FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z"
  }
}

platform.getSubnet

POST

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

Get information about a subnet.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getSubnetrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getSubnet

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getSubnet",
    "params": {
      "id": "11111111111111111111111111111111LpoYY"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getSubnet",
      "params": {
        "id": "11111111111111111111111111111111LpoYY"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getSubnet",
  "params": {
    "id": "11111111111111111111111111111111LpoYY"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getSubnet",
  "params": {
    "id": "11111111111111111111111111111111LpoYY"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "isPermissioned": false,
    "controlKeys": [],
    "threshold": "0",
    "locktime": "0"
  }
}

platform.getSubnets

POST

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

Get information about subnets.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getSubnetsrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getSubnets

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getSubnets",
    "params": {
      "ids": [
        "11111111111111111111111111111111LpoYY"
      ]
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getSubnets",
      "params": {
        "ids": [
          "11111111111111111111111111111111LpoYY"
        ]
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getSubnets",
  "params": {
    "ids": [
      "11111111111111111111111111111111LpoYY"
    ]
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getSubnets",
  "params": {
    "ids": [
      "11111111111111111111111111111111LpoYY"
    ]
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "subnets": []
  }
}

platform.getTimestamp

POST

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

Get the current P-Chain timestamp.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getTimestamprequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getTimestamp

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getTimestamp",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getTimestamp",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getTimestamp",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getTimestamp",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "timestamp": "2026-07-30T12:00:00Z"
  }
}

platform.getTotalStake

POST

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

Get the total stake on a subnet.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getTotalStakerequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getTotalStake

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getTotalStake",
    "params": {
      "subnetID": "11111111111111111111111111111111LpoYY"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getTotalStake",
      "params": {
        "subnetID": "11111111111111111111111111111111LpoYY"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getTotalStake",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getTotalStake",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "stake": "1000000000000000",
    "weight": "1000000000000000"
  }
}

platform.getTx

POST

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

Get a P-Chain transaction.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getTxrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getTx

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getTx",
    "params": {
      "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9",
      "encoding": "json"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getTx",
      "params": {
        "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9",
        "encoding": "json"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getTx",
  "params": {
    "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9",
    "encoding": "json"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getTx",
  "params": {
    "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9",
    "encoding": "json"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "tx": {
      "unsignedTx": {},
      "credentials": []
    },
    "encoding": "json"
  }
}

platform.getTxStatus

POST

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

Get the status of a P-Chain transaction.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getTxStatusrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getTxStatus

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getTxStatus",
    "params": {
      "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getTxStatus",
      "params": {
        "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getTxStatus",
  "params": {
    "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getTxStatus",
  "params": {
    "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "status": "Committed",
    "reason": ""
  }
}

platform.getUTXOs

POST

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

Get UTXOs controlled by the specified P-Chain addresses.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getUTXOsrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getUTXOs

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getUTXOs",
    "params": {
      "addresses": [
        "P-avax1pmgmagjcljjzuz2ve339dx82khm7q8getlegte"
      ],
      "limit": 1024,
      "encoding": "hex"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getUTXOs",
      "params": {
        "addresses": [
          "P-avax1pmgmagjcljjzuz2ve339dx82khm7q8getlegte"
        ],
        "limit": 1024,
        "encoding": "hex"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getUTXOs",
  "params": {
    "addresses": [
      "P-avax1pmgmagjcljjzuz2ve339dx82khm7q8getlegte"
    ],
    "limit": 1024,
    "encoding": "hex"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getUTXOs",
  "params": {
    "addresses": [
      "P-avax1pmgmagjcljjzuz2ve339dx82khm7q8getlegte"
    ],
    "limit": 1024,
    "encoding": "hex"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "numFetched": "0",
    "utxos": [],
    "endIndex": {
      "address": "",
      "utxo": ""
    },
    "encoding": "hex"
  }
}

platform.getValidatorFeeConfig

POST

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

Return the validator fee configuration.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getValidatorFeeConfigrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getValidatorFeeConfig

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getValidatorFeeConfig",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getValidatorFeeConfig",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getValidatorFeeConfig",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getValidatorFeeConfig",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "capacity": "1000000",
    "target": "500000",
    "minPrice": "1",
    "excessConversionConstant": "1000"
  }
}

platform.getValidatorFeeState

POST

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

Return the current validator fee state.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getValidatorFeeStaterequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getValidatorFeeState

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getValidatorFeeState",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getValidatorFeeState",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getValidatorFeeState",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getValidatorFeeState",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "excess": "0",
    "price": "1",
    "timestamp": "2026-07-30T12:00:00Z"
  }
}

platform.getValidatorsAt

POST

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

Get validators and weights at a P-Chain height.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.getValidatorsAtrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.getValidatorsAt

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.getValidatorsAt",
    "params": {
      "height": "proposed",
      "subnetID": "11111111111111111111111111111111LpoYY"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.getValidatorsAt",
      "params": {
        "height": "proposed",
        "subnetID": "11111111111111111111111111111111LpoYY"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getValidatorsAt",
  "params": {
    "height": "proposed",
    "subnetID": "11111111111111111111111111111111LpoYY"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.getValidatorsAt",
  "params": {
    "height": "proposed",
    "subnetID": "11111111111111111111111111111111LpoYY"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "validators": {}
  }
}

platform.issueTx

POST

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

Issue a signed P-Chain transaction.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.issueTxrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.issueTx

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.issueTx",
    "params": {
      "tx": "0x0000",
      "encoding": "hex"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.issueTx",
      "params": {
        "tx": "0x0000",
        "encoding": "hex"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.issueTx",
  "params": {
    "tx": "0x0000",
    "encoding": "hex"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.issueTx",
  "params": {
    "tx": "0x0000",
    "encoding": "hex"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9"
  }
}

platform.validatedBy

POST

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

Get the subnet that validates a blockchain.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.validatedByrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.validatedBy

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.validatedBy",
    "params": {
      "blockchainID": "2q9e4r..."
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.validatedBy",
      "params": {
        "blockchainID": "2q9e4r..."
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.validatedBy",
  "params": {
    "blockchainID": "2q9e4r..."
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.validatedBy",
  "params": {
    "blockchainID": "2q9e4r..."
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  }
}

platform.validates

POST

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

Get blockchains validated by a subnet.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringplatform.validatesrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

platform.validates

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "platform.validates",
    "params": {
      "subnetID": "11111111111111111111111111111111LpoYY"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "platform.validates",
      "params": {
        "subnetID": "11111111111111111111111111111111LpoYY"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.validates",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "platform.validates",
  "params": {
    "subnetID": "11111111111111111111111111111111LpoYY"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "blockchainIDs": []
  }
}

MAINNET / X-Chain

X-Chain

avm.getAllBalances

POST

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

Get balances of all assets controlled by an address.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringavm.getAllBalancesrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

avm.getAllBalances

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "avm.getAllBalances",
    "params": {
      "address": "X-avax1c79e0dd0susp7dc8udq34jgk2yvve7hapvdyht"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "avm.getAllBalances",
      "params": {
        "address": "X-avax1c79e0dd0susp7dc8udq34jgk2yvve7hapvdyht"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getAllBalances",
  "params": {
    "address": "X-avax1c79e0dd0susp7dc8udq34jgk2yvve7hapvdyht"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getAllBalances",
  "params": {
    "address": "X-avax1c79e0dd0susp7dc8udq34jgk2yvve7hapvdyht"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "balances": [
      {
        "asset": "AVAX",
        "balance": "102"
      }
    ]
  }
}

avm.getAssetDescription

POST

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

Get information about an X-Chain asset.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringavm.getAssetDescriptionrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

avm.getAssetDescription

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "avm.getAssetDescription",
    "params": {
      "assetID": "FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "avm.getAssetDescription",
      "params": {
        "assetID": "FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getAssetDescription",
  "params": {
    "assetID": "FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getAssetDescription",
  "params": {
    "assetID": "FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "assetID": "FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z",
    "name": "Avalanche",
    "symbol": "AVAX",
    "denomination": "9"
  }
}

avm.getBalance

POST

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

Get an asset balance controlled by an address.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringavm.getBalancerequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

avm.getBalance

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "avm.getBalance",
    "params": {
      "address": "X-avax18jma8ppw3nhx5r4ap8clazz0dps7rv5ukulre5",
      "assetID": "FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "avm.getBalance",
      "params": {
        "address": "X-avax18jma8ppw3nhx5r4ap8clazz0dps7rv5ukulre5",
        "assetID": "FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getBalance",
  "params": {
    "address": "X-avax18jma8ppw3nhx5r4ap8clazz0dps7rv5ukulre5",
    "assetID": "FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getBalance",
  "params": {
    "address": "X-avax18jma8ppw3nhx5r4ap8clazz0dps7rv5ukulre5",
    "assetID": "FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "balance": "299999999999900",
    "utxoIDs": []
  }
}

avm.getBlock

POST

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

Get an X-Chain block by ID.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringavm.getBlockrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

avm.getBlock

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "avm.getBlock",
    "params": {
      "blockID": "tXJ4xwmR8soHE6DzRNMQPtiwQvuYsHn6eLLBzo2moDqBquqy6",
      "encoding": "json"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "avm.getBlock",
      "params": {
        "blockID": "tXJ4xwmR8soHE6DzRNMQPtiwQvuYsHn6eLLBzo2moDqBquqy6",
        "encoding": "json"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getBlock",
  "params": {
    "blockID": "tXJ4xwmR8soHE6DzRNMQPtiwQvuYsHn6eLLBzo2moDqBquqy6",
    "encoding": "json"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getBlock",
  "params": {
    "blockID": "tXJ4xwmR8soHE6DzRNMQPtiwQvuYsHn6eLLBzo2moDqBquqy6",
    "encoding": "json"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "block": {
      "height": 1,
      "txs": []
    },
    "encoding": "json"
  }
}

avm.getBlockByHeight

POST

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

Get an X-Chain block by height.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringavm.getBlockByHeightrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

avm.getBlockByHeight

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "avm.getBlockByHeight",
    "params": {
      "height": "1",
      "encoding": "json"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "avm.getBlockByHeight",
      "params": {
        "height": "1",
        "encoding": "json"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getBlockByHeight",
  "params": {
    "height": "1",
    "encoding": "json"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getBlockByHeight",
  "params": {
    "height": "1",
    "encoding": "json"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "block": {
      "height": 1,
      "txs": []
    },
    "encoding": "json"
  }
}

avm.getHeight

POST

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

Get the height of the last accepted X-Chain block.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringavm.getHeightrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

avm.getHeight

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "avm.getHeight",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "avm.getHeight",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getHeight",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getHeight",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "height": "5094088"
  }
}

avm.getTx

POST

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

Get an X-Chain transaction.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringavm.getTxrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

avm.getTx

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "avm.getTx",
    "params": {
      "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9",
      "encoding": "json"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "avm.getTx",
      "params": {
        "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9",
        "encoding": "json"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getTx",
  "params": {
    "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9",
    "encoding": "json"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getTx",
  "params": {
    "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9",
    "encoding": "json"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "tx": {},
    "encoding": "json"
  }
}

avm.getTxFee

POST

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

Get X-Chain network fees.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringavm.getTxFeerequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

avm.getTxFee

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "avm.getTxFee",
    "params": {}
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "avm.getTxFee",
      "params": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getTxFee",
  "params": {}
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getTxFee",
  "params": {}
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "txFee": "1000000",
    "createAssetTxFee": "10000000"
  }
}

avm.getTxStatus

POST

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

Get the status of an X-Chain transaction.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringavm.getTxStatusrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

avm.getTxStatus

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "avm.getTxStatus",
    "params": {
      "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "avm.getTxStatus",
      "params": {
        "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getTxStatus",
  "params": {
    "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getTxStatus",
  "params": {
    "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "status": "Accepted"
  }
}

avm.getUTXOs

POST

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

Get UTXOs controlled by X-Chain addresses.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringavm.getUTXOsrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

avm.getUTXOs

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "avm.getUTXOs",
    "params": {
      "addresses": [
        "X-avax1c79e0dd0susp7dc8udq34jgk2yvve7hapvdyht"
      ],
      "limit": 1024,
      "encoding": "hex"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "avm.getUTXOs",
      "params": {
        "addresses": [
          "X-avax1c79e0dd0susp7dc8udq34jgk2yvve7hapvdyht"
        ],
        "limit": 1024,
        "encoding": "hex"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getUTXOs",
  "params": {
    "addresses": [
      "X-avax1c79e0dd0susp7dc8udq34jgk2yvve7hapvdyht"
    ],
    "limit": 1024,
    "encoding": "hex"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.getUTXOs",
  "params": {
    "addresses": [
      "X-avax1c79e0dd0susp7dc8udq34jgk2yvve7hapvdyht"
    ],
    "limit": 1024,
    "encoding": "hex"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "numFetched": "0",
    "utxos": [],
    "endIndex": {
      "address": "",
      "utxo": ""
    },
    "encoding": "hex"
  }
}

avm.issueTx

POST

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

Issue a signed X-Chain transaction.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringavm.issueTxrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

avm.issueTx

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "avm.issueTx",
    "params": {
      "tx": "0x0000",
      "encoding": "hex"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "avm.issueTx",
      "params": {
        "tx": "0x0000",
        "encoding": "hex"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.issueTx",
  "params": {
    "tx": "0x0000",
    "encoding": "hex"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "avm.issueTx",
  "params": {
    "tx": "0x0000",
    "encoding": "hex"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9"
  }
}

wallet.issueTx

POST

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

Issue a signed transaction.

Body

application/json

jsonrpcstring2.0required

idinteger | stringrequired

methodstringwallet.issueTxrequired

paramsobjectrequired

Response

200OK

Successful JSON-RPC response

400Bad Request

Invalid JSON-RPC request

401Unauthorized

Missing or invalid API key

429Too Many Requests

Rate limit exceeded

500Internal Server Error

Node or upstream error

Authorization

api-keyAuthapiKey in header

wallet.issueTx

curl -X POST 'https://avax-blockbook.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "wallet.issueTx",
    "params": {
      "tx": "0x0000",
      "encoding": "hex"
    }
  }'

const response = await fetch('https://avax-blockbook.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": 1,
      "method": "wallet.issueTx",
      "params": {
        "tx": "0x0000",
        "encoding": "hex"
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "wallet.issueTx",
  "params": {
    "tx": "0x0000",
    "encoding": "hex"
  }
}

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

Request Body

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "wallet.issueTx",
  "params": {
    "tx": "0x0000",
    "encoding": "hex"
  }
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "txID": "2ahK5SzD8iqi5KBqpKfxrnWtrEoVwQCqJsMoB9kvChCaHgAQC9"
  }
}

Documentation

Authentication

MAINNET / Blockbook

BlockBook

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

Parameters

Response

Authorization

MAINNET / C-Chain

C-Chain

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization

Body

Response

Authorization