API Reference

v1.0.0

Base URL

https://zil.nownodes.io

Authentication

api-keyAuthapiKey

API Key: api-key in header

MAINNET / API-Reference

default

Get latest DS block number

POST

https://zil.nownodes.io/GetLatestDsBlock

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the latest DS (Directory Service) block number.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

Method name

idintegerrequired

Request ID

paramsArray<string | integer | object | boolean>required

Parameters for the method (empty if none)

Show child attributes

One of

string

integer

object

boolean

Response

200OK

Latest DS block number retrieved successfully

Get latest DS block number

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

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://zil.nownodes.io/GetLatestDsBlock");
const result = await provider.send("GetLatestDsBlock", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://zil.nownodes.io/GetLatestDsBlock')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "GetLatestDsBlock",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://zil.nownodes.io/GetLatestDsBlock"))
response = w3.provider.make_request("GetLatestDsBlock", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://zil.nownodes.io/GetLatestDsBlock"),
});

const result = await client.request({
  method: "GetLatestDsBlock",
  params: [],
});

console.log(result);

const endpoint = "https://zil.nownodes.io/GetLatestDsBlock";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "GetLatestDsBlock", params: [], id: 1 });
console.log(result);

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

const data = await response.json();

import requests

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

response = requests.post('https://zil.nownodes.io/GetLatestDsBlock', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zil.nownodes.io/GetLatestDsBlock')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "GetLatestDsBlock",
    "id": 1,
    "params": []
  }'

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

Request Body

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

200

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

Get DS block creation rate

POST

https://zil.nownodes.io/GetDSBlockRate

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the rate of DS block creation in blocks per second.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

Method name

idintegerrequired

Request ID

paramsArray<string | integer | object | boolean>required

Parameters for the method (empty if none)

Show child attributes

One of

string

integer

object

boolean

Response

200OK

DS block creation rate retrieved successfully

Get DS block creation rate

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

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://zil.nownodes.io/GetDSBlockRate");
const result = await provider.send("GetDSBlockRate", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://zil.nownodes.io/GetDSBlockRate')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "GetDSBlockRate",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://zil.nownodes.io/GetDSBlockRate"))
response = w3.provider.make_request("GetDSBlockRate", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://zil.nownodes.io/GetDSBlockRate"),
});

const result = await client.request({
  method: "GetDSBlockRate",
  params: [],
});

console.log(result);

const endpoint = "https://zil.nownodes.io/GetDSBlockRate";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "GetDSBlockRate", params: [], id: 1 });
console.log(result);

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

const data = await response.json();

import requests

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

response = requests.post('https://zil.nownodes.io/GetDSBlockRate', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zil.nownodes.io/GetDSBlockRate')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "GetDSBlockRate",
    "id": 1,
    "params": []
  }'

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

Request Body

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

200

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

Get latest transaction block number

POST

https://zil.nownodes.io/GetLatestTxBlock

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the latest transaction (Tx) block number.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

Method name

idintegerrequired

Request ID

paramsArray<string | integer | object | boolean>required

Parameters for the method (empty if none)

Show child attributes

One of

string

integer

object

boolean

Response

200OK

Latest Tx block number retrieved successfully

Get latest transaction block number

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

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://zil.nownodes.io/GetLatestTxBlock");
const result = await provider.send("GetLatestTxBlock", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://zil.nownodes.io/GetLatestTxBlock')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "GetLatestTxBlock",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://zil.nownodes.io/GetLatestTxBlock"))
response = w3.provider.make_request("GetLatestTxBlock", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://zil.nownodes.io/GetLatestTxBlock"),
});

const result = await client.request({
  method: "GetLatestTxBlock",
  params: [],
});

console.log(result);

const endpoint = "https://zil.nownodes.io/GetLatestTxBlock";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "GetLatestTxBlock", params: [], id: 1 });
console.log(result);

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

const data = await response.json();

import requests

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

response = requests.post('https://zil.nownodes.io/GetLatestTxBlock', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zil.nownodes.io/GetLatestTxBlock')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "GetLatestTxBlock",
    "id": 1,
    "params": []
  }'

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

Request Body

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

200

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

Get network ID

POST

https://zil.nownodes.io/GetNetworkId

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the network ID of the connected Zilliqa network.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

Method name

idintegerrequired

Request ID

paramsArray<string | integer | object | boolean>required

Parameters for the method (empty if none)

Show child attributes

One of

string

integer

object

boolean

Response

200OK

Network ID retrieved successfully

Get network ID

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

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://zil.nownodes.io/GetNetworkId");
const result = await provider.send("GetNetworkId", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://zil.nownodes.io/GetNetworkId')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "GetNetworkId",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://zil.nownodes.io/GetNetworkId"))
response = w3.provider.make_request("GetNetworkId", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://zil.nownodes.io/GetNetworkId"),
});

const result = await client.request({
  method: "GetNetworkId",
  params: [],
});

console.log(result);

const endpoint = "https://zil.nownodes.io/GetNetworkId";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "GetNetworkId", params: [], id: 1 });
console.log(result);

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

const data = await response.json();

import requests

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

response = requests.post('https://zil.nownodes.io/GetNetworkId', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zil.nownodes.io/GetNetworkId')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "GetNetworkId",
    "id": 1,
    "params": []
  }'

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

Request Body

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

200

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

Get miner information

POST

https://zil.nownodes.io/GetMinerInfo

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information about the miner of the node.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

Method name

idintegerrequired

Request ID

paramsArray<string | integer | object | boolean>required

Parameters for the method (empty if none)

Show child attributes

One of

string

integer

object

boolean

Response

200OK

Miner information retrieved successfully

Get miner information

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

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://zil.nownodes.io/GetMinerInfo");
const result = await provider.send("GetMinerInfo", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://zil.nownodes.io/GetMinerInfo')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "GetMinerInfo",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://zil.nownodes.io/GetMinerInfo"))
response = w3.provider.make_request("GetMinerInfo", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://zil.nownodes.io/GetMinerInfo"),
});

const result = await client.request({
  method: "GetMinerInfo",
  params: [],
});

console.log(result);

const endpoint = "https://zil.nownodes.io/GetMinerInfo";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "GetMinerInfo", params: [], id: 1 });
console.log(result);

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

const data = await response.json();

import requests

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

response = requests.post('https://zil.nownodes.io/GetMinerInfo', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zil.nownodes.io/GetMinerInfo')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "GetMinerInfo",
    "id": 1,
    "params": []
  }'

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

Request Body

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

200

{
  "id": 1,
  "jsonrpc": "2.0",
  "result": {
    "address": "zil1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszq",
    "nodeVersion": "v6.1.0-rc1",
    "isMining": true,
    "currentShardID": 2
  }
}

Get node type

POST

https://zil.nownodes.io/GetNodeType

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the type of the current node.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

Method name

idintegerrequired

Request ID

paramsArray<string | integer | object | boolean>required

Parameters for the method (empty if none)

Show child attributes

One of

string

integer

object

boolean

Response

200OK

Node type retrieved successfully

Get node type

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

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://zil.nownodes.io/GetNodeType");
const result = await provider.send("GetNodeType", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://zil.nownodes.io/GetNodeType')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "GetNodeType",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://zil.nownodes.io/GetNodeType"))
response = w3.provider.make_request("GetNodeType", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://zil.nownodes.io/GetNodeType"),
});

const result = await client.request({
  method: "GetNodeType",
  params: [],
});

console.log(result);

const endpoint = "https://zil.nownodes.io/GetNodeType";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "GetNodeType", params: [], id: 1 });
console.log(result);

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

const data = await response.json();

import requests

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

response = requests.post('https://zil.nownodes.io/GetNodeType', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zil.nownodes.io/GetNodeType')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "GetNodeType",
    "id": 1,
    "params": []
  }'

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

Request Body

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

200

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

Get number of DS blocks

POST

https://zil.nownodes.io/GetNumDSBlocks

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of DS blocks created so far.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

Method name

idintegerrequired

Request ID

paramsArray<string | integer | object | boolean>required

Parameters for the method (empty if none)

Show child attributes

One of

string

integer

object

boolean

Response

200OK

Number of DS blocks retrieved successfully

Get number of DS blocks

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

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://zil.nownodes.io/GetNumDSBlocks");
const result = await provider.send("GetNumDSBlocks", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://zil.nownodes.io/GetNumDSBlocks')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "GetNumDSBlocks",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://zil.nownodes.io/GetNumDSBlocks"))
response = w3.provider.make_request("GetNumDSBlocks", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://zil.nownodes.io/GetNumDSBlocks"),
});

const result = await client.request({
  method: "GetNumDSBlocks",
  params: [],
});

console.log(result);

const endpoint = "https://zil.nownodes.io/GetNumDSBlocks";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "GetNumDSBlocks", params: [], id: 1 });
console.log(result);

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

const data = await response.json();

import requests

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

response = requests.post('https://zil.nownodes.io/GetNumDSBlocks', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zil.nownodes.io/GetNumDSBlocks')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "GetNumDSBlocks",
    "id": 1,
    "params": []
  }'

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

Request Body

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

200

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

Get number of peers

POST

https://zil.nownodes.io/GetNumPeers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the number of peers connected to this node.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

Method name

idintegerrequired

Request ID

paramsArray<string | integer | object | boolean>required

Parameters for the method (empty if none)

Show child attributes

One of

string

integer

object

boolean

Response

200OK

Number of peers retrieved successfully

Get number of peers

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

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://zil.nownodes.io/GetNumPeers");
const result = await provider.send("GetNumPeers", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://zil.nownodes.io/GetNumPeers')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "GetNumPeers",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://zil.nownodes.io/GetNumPeers"))
response = w3.provider.make_request("GetNumPeers", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://zil.nownodes.io/GetNumPeers"),
});

const result = await client.request({
  method: "GetNumPeers",
  params: [],
});

console.log(result);

const endpoint = "https://zil.nownodes.io/GetNumPeers";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "GetNumPeers", params: [], id: 1 });
console.log(result);

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

const data = await response.json();

import requests

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

response = requests.post('https://zil.nownodes.io/GetNumPeers', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zil.nownodes.io/GetNumPeers')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "GetNumPeers",
    "id": 1,
    "params": []
  }'

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

Request Body

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

200

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

Get number of transactions

POST

https://zil.nownodes.io/GetNumTransactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of transactions processed so far.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

Method name

idintegerrequired

Request ID

paramsArray<string | integer | object | boolean>required

Parameters for the method (empty if none)

Show child attributes

One of

string

integer

object

boolean

Response

200OK

Number of transactions retrieved successfully

Get number of transactions

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

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://zil.nownodes.io/GetNumTransactions");
const result = await provider.send("GetNumTransactions", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://zil.nownodes.io/GetNumTransactions')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "GetNumTransactions",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://zil.nownodes.io/GetNumTransactions"))
response = w3.provider.make_request("GetNumTransactions", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://zil.nownodes.io/GetNumTransactions"),
});

const result = await client.request({
  method: "GetNumTransactions",
  params: [],
});

console.log(result);

const endpoint = "https://zil.nownodes.io/GetNumTransactions";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "GetNumTransactions", params: [], id: 1 });
console.log(result);

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

const data = await response.json();

import requests

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

response = requests.post('https://zil.nownodes.io/GetNumTransactions', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zil.nownodes.io/GetNumTransactions')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "GetNumTransactions",
    "id": 1,
    "params": []
  }'

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

Request Body

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

200

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

Get number of transaction blocks

POST

https://zil.nownodes.io/GetNumTxBlocks

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of transaction blocks created so far.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

Method name

idintegerrequired

Request ID

paramsArray<string | integer | object | boolean>required

Parameters for the method (empty if none)

Show child attributes

One of

string

integer

object

boolean

Response

200OK

Number of transaction blocks retrieved successfully

Get number of transaction blocks

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

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://zil.nownodes.io/GetNumTxBlocks");
const result = await provider.send("GetNumTxBlocks", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://zil.nownodes.io/GetNumTxBlocks')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "GetNumTxBlocks",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://zil.nownodes.io/GetNumTxBlocks"))
response = w3.provider.make_request("GetNumTxBlocks", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://zil.nownodes.io/GetNumTxBlocks"),
});

const result = await client.request({
  method: "GetNumTxBlocks",
  params: [],
});

console.log(result);

const endpoint = "https://zil.nownodes.io/GetNumTxBlocks";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "GetNumTxBlocks", params: [], id: 1 });
console.log(result);

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

const data = await response.json();

import requests

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

response = requests.post('https://zil.nownodes.io/GetNumTxBlocks', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zil.nownodes.io/GetNumTxBlocks')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "GetNumTxBlocks",
    "id": 1,
    "params": []
  }'

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

Request Body

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

200

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

Get previous mining difficulty

POST

https://zil.nownodes.io/GetPrevDifficulty

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the mining difficulty of the previous transaction block.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

Method name

idintegerrequired

Request ID

paramsArray<string | integer | object | boolean>required

Parameters for the method (empty if none)

Show child attributes

One of

string

integer

object

boolean

Response

200OK

Previous transaction block difficulty retrieved successfully

Get previous mining difficulty

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

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://zil.nownodes.io/GetPrevDifficulty");
const result = await provider.send("GetPrevDifficulty", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://zil.nownodes.io/GetPrevDifficulty')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "GetPrevDifficulty",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://zil.nownodes.io/GetPrevDifficulty"))
response = w3.provider.make_request("GetPrevDifficulty", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://zil.nownodes.io/GetPrevDifficulty"),
});

const result = await client.request({
  method: "GetPrevDifficulty",
  params: [],
});

console.log(result);

const endpoint = "https://zil.nownodes.io/GetPrevDifficulty";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "GetPrevDifficulty", params: [], id: 1 });
console.log(result);

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

const data = await response.json();

import requests

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

response = requests.post('https://zil.nownodes.io/GetPrevDifficulty', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zil.nownodes.io/GetPrevDifficulty')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "GetPrevDifficulty",
    "id": 1,
    "params": []
  }'

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

Request Body

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

200

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

Get previous DS block difficulty

POST

https://zil.nownodes.io/GetPrevDSDifficulty

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the mining difficulty of the previous DS block.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

Method name

idintegerrequired

Request ID

paramsArray<string | integer | object | boolean>required

Parameters for the method (empty if none)

Show child attributes

One of

string

integer

object

boolean

Response

200OK

Previous DS block difficulty retrieved successfully

Get previous DS block difficulty

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

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://zil.nownodes.io/GetPrevDSDifficulty");
const result = await provider.send("GetPrevDSDifficulty", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://zil.nownodes.io/GetPrevDSDifficulty')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "GetPrevDSDifficulty",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://zil.nownodes.io/GetPrevDSDifficulty"))
response = w3.provider.make_request("GetPrevDSDifficulty", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://zil.nownodes.io/GetPrevDSDifficulty"),
});

const result = await client.request({
  method: "GetPrevDSDifficulty",
  params: [],
});

console.log(result);

const endpoint = "https://zil.nownodes.io/GetPrevDSDifficulty";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "GetPrevDSDifficulty", params: [], id: 1 });
console.log(result);

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

const data = await response.json();

import requests

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

response = requests.post('https://zil.nownodes.io/GetPrevDSDifficulty', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zil.nownodes.io/GetPrevDSDifficulty')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "GetPrevDSDifficulty",
    "id": 1,
    "params": []
  }'

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

Request Body

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

200

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

Get current sharding structure

POST

https://zil.nownodes.io/GetShardingStructure

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the current sharding structure of the Zilliqa network including shards and DS committee members.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

Method name

idintegerrequired

Request ID

paramsArray<string | integer | object | boolean>required

Parameters for the method (empty if none)

Show child attributes

One of

string

integer

object

boolean

Response

200OK

Sharding structure retrieved successfully

Get current sharding structure

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

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://zil.nownodes.io/GetShardingStructure");
const result = await provider.send("GetShardingStructure", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://zil.nownodes.io/GetShardingStructure')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "GetShardingStructure",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://zil.nownodes.io/GetShardingStructure"))
response = w3.provider.make_request("GetShardingStructure", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://zil.nownodes.io/GetShardingStructure"),
});

const result = await client.request({
  method: "GetShardingStructure",
  params: [],
});

console.log(result);

const endpoint = "https://zil.nownodes.io/GetShardingStructure";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "GetShardingStructure", params: [], id: 1 });
console.log(result);

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

const data = await response.json();

import requests

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

response = requests.post('https://zil.nownodes.io/GetShardingStructure', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zil.nownodes.io/GetShardingStructure')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "GetShardingStructure",
    "id": 1,
    "params": []
  }'

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

Request Body

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

200

{
  "id": 1,
  "jsonrpc": "2.0",
  "result": {
    "shards": [
      {
        "shardID": 0,
        "nodes": [
          "node1.example.com"
        ]
      }
    ],
    "dsCommittee": [
      "dsnode1.example.com"
    ]
  }
}

Get node software version

POST

https://zil.nownodes.io/GetVersion

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the current node software version.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

Method name

idintegerrequired

Request ID

paramsArray<string | integer | object | boolean>required

Parameters for the method (empty if none)

Show child attributes

One of

string

integer

object

boolean

Response

200OK

Node version retrieved successfully

Get node software version

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

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://zil.nownodes.io/GetVersion");
const result = await provider.send("GetVersion", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://zil.nownodes.io/GetVersion')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "GetVersion",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://zil.nownodes.io/GetVersion"))
response = w3.provider.make_request("GetVersion", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://zil.nownodes.io/GetVersion"),
});

const result = await client.request({
  method: "GetVersion",
  params: [],
});

console.log(result);

const endpoint = "https://zil.nownodes.io/GetVersion";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "GetVersion", params: [], id: 1 });
console.log(result);

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

const data = await response.json();

import requests

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

response = requests.post('https://zil.nownodes.io/GetVersion', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zil.nownodes.io/GetVersion')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "GetVersion",
    "id": 1,
    "params": []
  }'

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

Request Body

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

200

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

Get total coin supply

POST

https://zil.nownodes.io/GetTotalCoinSupply

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total circulating supply of ZIL coins.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

Method name

idintegerrequired

Request ID

paramsArray<string | integer | object | boolean>required

Parameters for the method (empty if none)

Show child attributes

One of

string

integer

object

boolean

Response

200OK

Total coin supply retrieved successfully

Get total coin supply

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

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://zil.nownodes.io/GetTotalCoinSupply");
const result = await provider.send("GetTotalCoinSupply", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://zil.nownodes.io/GetTotalCoinSupply')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "GetTotalCoinSupply",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://zil.nownodes.io/GetTotalCoinSupply"))
response = w3.provider.make_request("GetTotalCoinSupply", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://zil.nownodes.io/GetTotalCoinSupply"),
});

const result = await client.request({
  method: "GetTotalCoinSupply",
  params: [],
});

console.log(result);

const endpoint = "https://zil.nownodes.io/GetTotalCoinSupply";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "GetTotalCoinSupply", params: [], id: 1 });
console.log(result);

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

const data = await response.json();

import requests

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

response = requests.post('https://zil.nownodes.io/GetTotalCoinSupply', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zil.nownodes.io/GetTotalCoinSupply')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "GetTotalCoinSupply",
    "id": 1,
    "params": []
  }'

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

Request Body

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

200

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

Get transaction block details by block number

POST

https://zil.nownodes.io/GetTxBlock

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns detailed information about a specific transaction block by its number.

Body

application/json

jsonrpcstring

JSON-RPC version

methodstring

Method name

idinteger

Request ID

paramsArray<integer>

Array with block number (height) as parameter

Response

200OK

Transaction block details retrieved successfully

Get transaction block details by block number

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

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://zil.nownodes.io/GetTxBlock");
const result = await provider.send("GetTxBlock", [
  12345
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://zil.nownodes.io/GetTxBlock')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "GetTxBlock",
  "params": [
    12345
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://zil.nownodes.io/GetTxBlock"))
response = w3.provider.make_request("GetTxBlock", [
  12345
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://zil.nownodes.io/GetTxBlock"),
});

const result = await client.request({
  method: "GetTxBlock",
  params: [
  12345
],
});

console.log(result);

const endpoint = "https://zil.nownodes.io/GetTxBlock";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "GetTxBlock", params: [
  12345
], id: 1 });
console.log(result);

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

const data = await response.json();

import requests

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

response = requests.post('https://zil.nownodes.io/GetTxBlock', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zil.nownodes.io/GetTxBlock')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "GetTxBlock",
    "id": 1,
    "params": [
      12345
    ]
  }'

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

Request Body

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

200

{
  "id": 1,
  "jsonrpc": "2.0",
  "result": {
    "header": {
      "blockNum": 12345,
      "prevBlockHash": "0xabcdef1234567890...",
      "timestamp": 1627889182,
      "txCount": 10,
      "dsBlockNum": 789,
      "gasLimit": "5000000"
    },
    "txs": [
      {
        "txID": "0x1234abcd5678ef90",
        "sender": "zil1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszq",
        "recipient": "zil1p9xtfkr6x0js4v5hj8q9k3j0e6p3vxtl7hsv8z",
        "amount": "1000000000000",
        "gasPrice": "1000000000",
        "gasUsed": "21000",
        "data": "0x"
      }
    ]
  }
}

Get transaction block creation rate

POST

https://zil.nownodes.io/GetTxBlockRate

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the average rate at which transaction blocks are created.

Body

application/json

jsonrpcstringrequired

JSON-RPC version

methodstringrequired

Method name

idintegerrequired

Request ID

paramsArray<string | integer | object | boolean>required

Parameters for the method (empty if none)

Show child attributes

One of

string

integer

object

boolean

Response

200OK

Transaction block creation rate retrieved successfully

Get transaction block creation rate

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

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://zil.nownodes.io/GetTxBlockRate");
const result = await provider.send("GetTxBlockRate", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://zil.nownodes.io/GetTxBlockRate')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "GetTxBlockRate",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://zil.nownodes.io/GetTxBlockRate"))
response = w3.provider.make_request("GetTxBlockRate", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://zil.nownodes.io/GetTxBlockRate"),
});

const result = await client.request({
  method: "GetTxBlockRate",
  params: [],
});

console.log(result);

const endpoint = "https://zil.nownodes.io/GetTxBlockRate";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({ jsonrpc: "2.0", method: "GetTxBlockRate", params: [], id: 1 });
console.log(result);

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

const data = await response.json();

import requests

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

response = requests.post('https://zil.nownodes.io/GetTxBlockRate', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://zil.nownodes.io/GetTxBlockRate')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "method": "GetTxBlockRate",
    "id": 1,
    "params": []
  }'

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

Request Body

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

200

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

Documentation

How to migrate to NOWNodes

Authentication

MAINNET / API-Reference

default

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response