Octez RPC

v19.2 (54a1580334)

Base URL

https://xtz.nownodes.io

The RPC API served by the Octez node.

Authentication

api-keyAuthapiKey

API Key: api-key in header

Node

Chains

GET

https://xtz.nownodes.io/chains/{chain_id}/blocks

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Lists block hashes from '', up to the last checkpoint, sorted with decreasing fitness. Without arguments it returns the head of the chain. Optional arguments allow to return the list of predecessors of a given block or of a set of blocks.

Parameters

chain_idstringrequiredpath

A chain identifier. This is either a chain hash in Base58Check notation or a one the predefined aliases: 'main', 'test'.

lengthstringquery

The requested number of predecessors to return (per request; see next argument).

headstringquery

block_hash (Base58Check-encoded) An empty argument requests blocks starting with the current head. A non empty list allows to request one or more specific fragments of the chain.

min_datestringquery

A date in seconds from epoch When min_date is provided, blocks with a timestamp before min_date are filtered out. However, if the length parameter is also provided, then up to that number of predecessors will be returned regardless of their date.

Response

200OK

Valid response

default

GET /chains/{chain_id}/blocks

curl -X GET 'https://xtz.nownodes.io/chains/{chain_id}/blocks'

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/blocks', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/chains/{chain_id}/blocks')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/chains/{chain_id}/blocks')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/blocks', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/chains/{chain_id}/blocks";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/blocks', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/chains/{chain_id}/blocks')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/chains/{chain_id}/blocks')
request = Net::HTTP::Get.new(uri)

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

200

[
  [
    "string"
  ]
]

GET

https://xtz.nownodes.io/chains/{chain_id}/chain_id

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

The chain unique identifier.

Parameters

chain_idstringrequiredpath

A chain identifier. This is either a chain hash in Base58Check notation or a one the predefined aliases: 'main', 'test'.

Response

200OK

Valid response

default

GET /chains/{chain_id}/chain_id

curl -X GET 'https://xtz.nownodes.io/chains/{chain_id}/chain_id'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/chains/{chain_id}/chain_id')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/chains/{chain_id}/chain_id')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/chains/{chain_id}/chain_id";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/chains/{chain_id}/chain_id')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/chains/{chain_id}/chain_id')
request = Net::HTTP::Get.new(uri)

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

200

"string"

GET

https://xtz.nownodes.io/chains/{chain_id}/checkpoint

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

DEPRECATED: use ../levels/{checkpoint, savepoint, caboose, history_mode} instead. The current checkpoint for this chain.

Parameters

chain_idstringrequiredpath

A chain identifier. This is either a chain hash in Base58Check notation or a one the predefined aliases: 'main', 'test'.

Response

200OK

Valid response

default

GET /chains/{chain_id}/checkpoint

curl -X GET 'https://xtz.nownodes.io/chains/{chain_id}/checkpoint'

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/checkpoint', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/chains/{chain_id}/checkpoint')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/chains/{chain_id}/checkpoint')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/checkpoint', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/chains/{chain_id}/checkpoint";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/checkpoint', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/chains/{chain_id}/checkpoint')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/chains/{chain_id}/checkpoint')
request = Net::HTTP::Get.new(uri)

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

200

{
  "block": {
    "level": -2147483648,
    "proto": 0,
    "predecessor": "string",
    "timestamp": "string",
    "validation_pass": 0,
    "operations_hash": "string",
    "fitness": [
      "string"
    ],
    "context": "string",
    "protocol_data": "string"
  },
  "savepoint": -2147483648,
  "caboose": -2147483648,
  "history_mode": "archive"
}

GET

https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Lists blocks that have been declared invalid along with the errors that led to them being declared invalid.

Parameters

chain_idstringrequiredpath

A chain identifier. This is either a chain hash in Base58Check notation or a one the predefined aliases: 'main', 'test'.

Response

200OK

Valid response

default

GET /chains/{chain_id}/invalid_blocks

curl -X GET 'https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks'

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks')
request = Net::HTTP::Get.new(uri)

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

200

[
  {
    "block": "string",
    "level": -2147483648
  }
]

GET

https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks/{block_hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

The errors that appears during the block (in)validation.

Parameters

chain_idstringrequiredpath

A chain identifier. This is either a chain hash in Base58Check notation or a one the predefined aliases: 'main', 'test'.

block_hashstringrequiredpath

block_hash (Base58Check-encoded)

Response

200OK

Valid response

default

GET /chains/{chain_id}/invalid_blocks/{block_hash}

curl -X GET 'https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks/{block_hash}'

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks/{block_hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks/{block_hash}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks/{block_hash}')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks/{block_hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks/{block_hash}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks/{block_hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks/{block_hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/chains/{chain_id}/invalid_blocks/{block_hash}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "block": "string",
  "level": -2147483648
}

GET

https://xtz.nownodes.io/chains/{chain_id}/is_bootstrapped

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

The bootstrap status of a chain

Parameters

chain_idstringrequiredpath

A chain identifier. This is either a chain hash in Base58Check notation or a one the predefined aliases: 'main', 'test'.

Response

200OK

Valid response

default

GET /chains/{chain_id}/is_bootstrapped

curl -X GET 'https://xtz.nownodes.io/chains/{chain_id}/is_bootstrapped'

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/is_bootstrapped', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/chains/{chain_id}/is_bootstrapped')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/chains/{chain_id}/is_bootstrapped')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/is_bootstrapped', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/chains/{chain_id}/is_bootstrapped";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/is_bootstrapped', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/chains/{chain_id}/is_bootstrapped')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/chains/{chain_id}/is_bootstrapped')
request = Net::HTTP::Get.new(uri)

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

200

{
  "bootstrapped": true,
  "sync_state": "stuck"
}

GET

https://xtz.nownodes.io/chains/{chain_id}/levels/caboose

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

The current caboose for this chain.

Parameters

chain_idstringrequiredpath

A chain identifier. This is either a chain hash in Base58Check notation or a one the predefined aliases: 'main', 'test'.

Response

200OK

Valid response

default

GET /chains/{chain_id}/levels/caboose

curl -X GET 'https://xtz.nownodes.io/chains/{chain_id}/levels/caboose'

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/levels/caboose', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/chains/{chain_id}/levels/caboose')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/chains/{chain_id}/levels/caboose')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/levels/caboose', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/chains/{chain_id}/levels/caboose";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/levels/caboose', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/chains/{chain_id}/levels/caboose')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/chains/{chain_id}/levels/caboose')
request = Net::HTTP::Get.new(uri)

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

200

{
  "block_hash": "string",
  "level": -2147483648
}

GET

https://xtz.nownodes.io/chains/{chain_id}/levels/checkpoint

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

The current checkpoint for this chain.

Parameters

chain_idstringrequiredpath

A chain identifier. This is either a chain hash in Base58Check notation or a one the predefined aliases: 'main', 'test'.

Response

200OK

Valid response

default

GET /chains/{chain_id}/levels/checkpoint

curl -X GET 'https://xtz.nownodes.io/chains/{chain_id}/levels/checkpoint'

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/levels/checkpoint', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/chains/{chain_id}/levels/checkpoint')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/chains/{chain_id}/levels/checkpoint')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/levels/checkpoint', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/chains/{chain_id}/levels/checkpoint";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/levels/checkpoint', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/chains/{chain_id}/levels/checkpoint')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/chains/{chain_id}/levels/checkpoint')
request = Net::HTTP::Get.new(uri)

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

200

{
  "block_hash": "string",
  "level": -2147483648
}

GET

https://xtz.nownodes.io/chains/{chain_id}/levels/savepoint

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

The current savepoint for this chain.

Parameters

chain_idstringrequiredpath

A chain identifier. This is either a chain hash in Base58Check notation or a one the predefined aliases: 'main', 'test'.

Response

200OK

Valid response

default

GET /chains/{chain_id}/levels/savepoint

curl -X GET 'https://xtz.nownodes.io/chains/{chain_id}/levels/savepoint'

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/levels/savepoint', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/chains/{chain_id}/levels/savepoint')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/chains/{chain_id}/levels/savepoint')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/levels/savepoint', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/chains/{chain_id}/levels/savepoint";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/chains/{chain_id}/levels/savepoint', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/chains/{chain_id}/levels/savepoint')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/chains/{chain_id}/levels/savepoint')
request = Net::HTTP::Get.new(uri)

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

200

{
  "block_hash": "string",
  "level": -2147483648
}

Config

GET

https://xtz.nownodes.io/config

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Return the runtime node configuration (this takes into account the command-line arguments and the on-disk configuration file)

Response

200OK

Valid response

default

GET /config

curl -X GET 'https://xtz.nownodes.io/config'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

response = requests.get('https://xtz.nownodes.io/config')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/config";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/config')
data = response.json()

require 'net/http'
require 'json'

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

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

200

{
  "data-dir": "string",
  "disable-config-validation": true,
  "rpc": {
    "listen-addrs": [
      "string"
    ],
    "listen-addr": "string",
    "cors-origin": [
      "string"
    ],
    "cors-headers": [
      "string"
    ],
    "crt": "string",
    "key": "string",
    "acl": [
      {
        "address": "string",
        "whitelist": [
          "string"
        ]
      }
    ],
    "media-type": "json"
  },
  "p2p": {
    "expected-proof-of-work": 0,
    "bootstrap-peers": [
      "string"
    ],
    "listen-addr": "string",
    "advertised-net-port": 0,
    "discovery-addr": "string",
    "private-mode": true,
    "limits": {
      "connection-timeout": 0,
      "authentication-timeout": 0,
      "min-connections": 0,
      "expected-connections": 0,
      "max-connections": 0,
      "backlog": 0,
      "max-incoming-connections": 0,
      "max-download-speed": -1073741824,
      "max-upload-speed": -1073741824,
      "swap-linger": 0,
      "binary-chunks-size": 0,
      "read-buffer-size": -1073741824,
      "read-queue-size": -1073741824,
      "write-queue-size": -1073741824,
      "incoming-app-message-queue-size": -1073741824,
      "incoming-message-queue-size": -1073741824,
      "outgoing-message-queue-size": -1073741824,
      "max_known_points": [
        0
      ],
      "max_known_peer_ids": [
        0
      ],
      "peer_greylist_size": 0,
      "ip_greylist_size_in_kilobytes": 0,
      "ip_greylist_cleanup_delay": 0,
      "greylist-timeout": 0,
      "maintenance-idle-time": 0
    },
    "disable_mempool": true,
    "enable_testchain": true,
    "greylisting_config": {
      "factor": 0,
      "initial-delay": 0,
      "disconnection-delay": 0,
      "increase-cap": 0
    },
    "disable_peer_discovery": true
  },
  "log": {
    "output": "string",
    "level": "info",
    "colors": true,
    "rules": "string"
  },
  "internal-events": {
    "active_sinks": [
      "string"
    ]
  },
  "shell": {
    "peer_validator": {
      "block_header_request_timeout": 0,
      "block_operations_request_timeout": 0,
      "protocol_request_timeout": 0,
      "new_head_request_timeout": 0
    },
    "block_validator": {
      "protocol_request_timeout": 0,
      "operation_metadata_size_limit": "unlimited"
    },
    "prevalidator": {
      "operations_request_timeout": 0,
      "max_refused_operations": 0,
      "operations_batch_size": -1073741824
    },
    "chain_validator": {
      "latency": 0,
      "synchronisation_threshold": 0
    },
    "history_mode": "archive"
  },
  "network": "sandbox",
  "metrics_addr": [
    "string"
  ]
}

GET

https://xtz.nownodes.io/config/history_mode

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the history mode of the node's underlying storage.

Response

200OK

Valid response

default

GET /config/history_mode

curl -X GET 'https://xtz.nownodes.io/config/history_mode'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/config/history_mode')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/config/history_mode')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/config/history_mode";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/config/history_mode')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/config/history_mode')
request = Net::HTTP::Get.new(uri)

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

200

{
  "history_mode": "archive"
}

GET

https://xtz.nownodes.io/config/network/dal

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Configuration for the DAL

Response

200OK

Valid response

default

GET /config/network/dal

curl -X GET 'https://xtz.nownodes.io/config/network/dal'

const response = await fetch('https://xtz.nownodes.io/config/network/dal', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/config/network/dal')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/config/network/dal')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/config/network/dal', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/config/network/dal";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/config/network/dal', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/config/network/dal')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/config/network/dal')
request = Net::HTTP::Get.new(uri)

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

200

{
  "activated": true,
  "use_mock_srs_for_testing": true,
  "bootstrap_peers": [
    "string"
  ]
}

GET

https://xtz.nownodes.io/config/network/user_activated_protocol_overrides

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

List of protocols which replace other protocols

Response

200OK

Valid response

default

GET /config/network/user_activated_protocol_overrides

curl -X GET 'https://xtz.nownodes.io/config/network/user_activated_protocol_overrides'

const response = await fetch('https://xtz.nownodes.io/config/network/user_activated_protocol_overrides', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/config/network/user_activated_protocol_overrides')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/config/network/user_activated_protocol_overrides')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/config/network/user_activated_protocol_overrides', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/config/network/user_activated_protocol_overrides";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/config/network/user_activated_protocol_overrides', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/config/network/user_activated_protocol_overrides')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/config/network/user_activated_protocol_overrides')
request = Net::HTTP::Get.new(uri)

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

200

[
  {
    "replaced_protocol": "string",
    "replacement_protocol": "string"
  }
]

GET

https://xtz.nownodes.io/config/network/user_activated_upgrades

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

List of protocols to switch to at given levels

Response

200OK

Valid response

default

GET /config/network/user_activated_upgrades

curl -X GET 'https://xtz.nownodes.io/config/network/user_activated_upgrades'

const response = await fetch('https://xtz.nownodes.io/config/network/user_activated_upgrades', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/config/network/user_activated_upgrades')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/config/network/user_activated_upgrades')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/config/network/user_activated_upgrades', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/config/network/user_activated_upgrades";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/config/network/user_activated_upgrades', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/config/network/user_activated_upgrades')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/config/network/user_activated_upgrades')
request = Net::HTTP::Get.new(uri)

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

200

[
  {
    "level": -2147483648,
    "replacement_protocol": "string"
  }
]

Errors

GET

https://xtz.nownodes.io/errors

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Schema for all the RPC errors from the shell

Response

200OK

Valid response

default

GET /errors

curl -X GET 'https://xtz.nownodes.io/errors'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

response = requests.get('https://xtz.nownodes.io/errors')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/errors";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/errors')
data = response.json()

require 'net/http'
require 'json'

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

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

Fetch_protocol

GET

https://xtz.nownodes.io/fetch_protocol/{Protocol_hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Fetch a protocol from the network.

Parameters

Protocol_hashstringrequiredpath

Protocol_hash (Base58Check-encoded)

Response

200OK

Valid response

default

GET /fetch_protocol/{Protocol_hash}

curl -X GET 'https://xtz.nownodes.io/fetch_protocol/{Protocol_hash}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/fetch_protocol/{Protocol_hash}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/fetch_protocol/{Protocol_hash}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/fetch_protocol/{Protocol_hash}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/fetch_protocol/{Protocol_hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/fetch_protocol/{Protocol_hash}')
request = Net::HTTP::Get.new(uri)

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

Injection

POST

https://xtz.nownodes.io/injection/block

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Inject a block in the node and broadcast it. The operations embedded in blockHeader might be pre-validated using a contextual RPCs from the latest block (e.g. '/blocks/head/context/preapply'). Returns the ID of the block. By default, the RPC will wait for the block to be validated before answering. If ?async is true, the function returns immediately. Otherwise, the block will be validated before the result is returned. If ?force is true, it will be injected even on non strictly increasing fitness. An optional ?chain parameter can be used to specify whether to inject on the test chain or the main chain.

Body

application/json

datastringrequired

operationsArray<Array<operation>>required

Parameters

asyncstringquery

forcestringquery

chainstringquery

A chain identifier. This is either a chain hash in Base58Check notation or a one the predefined aliases: 'main', 'test'.

Response

200OK

Valid response

default

POST /injection/block

curl -X POST 'https://xtz.nownodes.io/injection/block' \
  -H 'Content-Type: application/json' \
  -d '{
    "data": "string",
    "operations": [
      [
        {
          "branch": "string",
          "data": "string"
        }
      ]
    ]
  }'

const response = await fetch('https://xtz.nownodes.io/injection/block', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "data": "string",
      "operations": [
        [
          {
            "branch": "string",
            "data": "string"
          }
        ]
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/injection/block')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "data": "string",
    "operations": [
      [
        {
          "branch": "string",
          "data": "string"
        }
      ]
    ]
  }'

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

import requests

payload = {
  "data": "string",
  "operations": [
    [
      {
        "branch": "string",
        "data": "string"
      }
    ]
  ]
}

response = requests.post('https://xtz.nownodes.io/injection/block', json=payload)
data = response.json()

const response = await fetch('https://xtz.nownodes.io/injection/block', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "data": "string",
      "operations": [
        [
          {
            "branch": "string",
            "data": "string"
          }
        ]
      ]
    }),
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/injection/block";
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({
    "data": "string",
    "operations": [
      [
        {
          "branch": "string",
          "data": "string"
        }
      ]
    ]
  });
console.log(result);

const response = await fetch('https://xtz.nownodes.io/injection/block', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "data": "string",
      "operations": [
        [
          {
            "branch": "string",
            "data": "string"
          }
        ]
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "data": "string",
  "operations": [
    [
      {
        "branch": "string",
        "data": "string"
      }
    ]
  ]
}

response = requests.post('https://xtz.nownodes.io/injection/block', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/injection/block')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "data": "string",
    "operations": [
      [
        {
          "branch": "string",
          "data": "string"
        }
      ]
    ]
  }'

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

Request Body

{
  "data": "string",
  "operations": [
    [
      {
        "branch": "string",
        "data": "string"
      }
    ]
  ]
}

200

"string"

POST

https://xtz.nownodes.io/injection/operation

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Inject an operation in node and broadcast it. Returns the ID of the operation. The signedOperationContents should be constructed using contextual RPCs from the latest block and signed by the client. The injection of the operation will apply it on the current mempool context. This context may change at each operation injection or operation reception from peers. By default, the RPC will wait for the operation to be (pre-)validated before returning. However, if ?async is true, the function returns immediately. The optional ?chain parameter can be used to specify whether to inject on the test chain or the main chain.

Body

application/json

string

Parameters

asyncstringquery

chainstringquery

A chain identifier. This is either a chain hash in Base58Check notation or a one the predefined aliases: 'main', 'test'.

Response

200OK

Valid response

default

POST /injection/operation

curl -X POST 'https://xtz.nownodes.io/injection/operation' \
  -H 'Content-Type: application/json' \
  -d '"string"'

const response = await fetch('https://xtz.nownodes.io/injection/operation', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify("string"),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/injection/operation')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '"string"'

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

import requests

payload = "string"

response = requests.post('https://xtz.nownodes.io/injection/operation', json=payload)
data = response.json()

const response = await fetch('https://xtz.nownodes.io/injection/operation', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify("string"),
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/injection/operation";
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("string");
console.log(result);

const response = await fetch('https://xtz.nownodes.io/injection/operation', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify("string"),
});

const data = await response.json();

import requests

payload = "string"

response = requests.post('https://xtz.nownodes.io/injection/operation', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/injection/operation')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '"string"'

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

Request Body

"string"

200

"string"

POST

https://xtz.nownodes.io/injection/protocol

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Inject a protocol in node. Returns the ID of the protocol. If ?async is true, the function returns immediately. Otherwise, the protocol will be validated before the result is returned.

Body

application/json

The environment a protocol relies on and the components a protocol is made of.

expected_env_versionprotocol.environment_version[0, 65535]required

componentsArray<object>required

Show child attributes

namestring | objectrequired

Either a plain UTF8 string, or a sequence of bytes for strings that contain invalid byte sequences.

interfacestring | object

Either a plain UTF8 string, or a sequence of bytes for strings that contain invalid byte sequences.

implementationstring | objectrequired

Either a plain UTF8 string, or a sequence of bytes for strings that contain invalid byte sequences.

Parameters

asyncstringquery

Response

200OK

Valid response

default

POST /injection/protocol

curl -X POST 'https://xtz.nownodes.io/injection/protocol' \
  -H 'Content-Type: application/json' \
  -d '{
    "expected_env_version": 0,
    "components": [
      {
        "name": "string",
        "interface": "string",
        "implementation": "string"
      }
    ]
  }'

const response = await fetch('https://xtz.nownodes.io/injection/protocol', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "expected_env_version": 0,
      "components": [
        {
          "name": "string",
          "interface": "string",
          "implementation": "string"
        }
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/injection/protocol')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "expected_env_version": 0,
    "components": [
      {
        "name": "string",
        "interface": "string",
        "implementation": "string"
      }
    ]
  }'

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

import requests

payload = {
  "expected_env_version": 0,
  "components": [
    {
      "name": "string",
      "interface": "string",
      "implementation": "string"
    }
  ]
}

response = requests.post('https://xtz.nownodes.io/injection/protocol', json=payload)
data = response.json()

const response = await fetch('https://xtz.nownodes.io/injection/protocol', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "expected_env_version": 0,
      "components": [
        {
          "name": "string",
          "interface": "string",
          "implementation": "string"
        }
      ]
    }),
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/injection/protocol";
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({
    "expected_env_version": 0,
    "components": [
      {
        "name": "string",
        "interface": "string",
        "implementation": "string"
      }
    ]
  });
console.log(result);

const response = await fetch('https://xtz.nownodes.io/injection/protocol', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "expected_env_version": 0,
      "components": [
        {
          "name": "string",
          "interface": "string",
          "implementation": "string"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "expected_env_version": 0,
  "components": [
    {
      "name": "string",
      "interface": "string",
      "implementation": "string"
    }
  ]
}

response = requests.post('https://xtz.nownodes.io/injection/protocol', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/injection/protocol')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "expected_env_version": 0,
    "components": [
      {
        "name": "string",
        "interface": "string",
        "implementation": "string"
      }
    ]
  }'

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

Request Body

{
  "expected_env_version": 0,
  "components": [
    {
      "name": "string",
      "interface": "string",
      "implementation": "string"
    }
  ]
}

200

"string"

Monitor

GET

https://xtz.nownodes.io/monitor/active_chains

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Monitor every chain creation and destruction. Currently active chains will be given as first elements

Response

200OK

Valid response

default

GET /monitor/active_chains

curl -X GET 'https://xtz.nownodes.io/monitor/active_chains'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/monitor/active_chains')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/monitor/active_chains')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/monitor/active_chains";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/monitor/active_chains')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/monitor/active_chains')
request = Net::HTTP::Get.new(uri)

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

200

[
  {
    "chain_id": "string"
  }
]

GET

https://xtz.nownodes.io/monitor/applied_blocks

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Monitor all blocks that are successfully applied and stored by the node, disregarding whether they were selected as the new head or not.

Parameters

protocolstringquery

Protocol_hash (Base58Check-encoded)

next_protocolstringquery

Protocol_hash (Base58Check-encoded)

chainstringquery

A chain identifier. This is either a chain hash in Base58Check notation or a one the predefined aliases: 'main', 'test'.

Response

200OK

Valid response

default

GET /monitor/applied_blocks

curl -X GET 'https://xtz.nownodes.io/monitor/applied_blocks'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/monitor/applied_blocks')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/monitor/applied_blocks')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/monitor/applied_blocks";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/monitor/applied_blocks')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/monitor/applied_blocks')
request = Net::HTTP::Get.new(uri)

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

200

{
  "chain_id": "string",
  "hash": "string",
  "header": {
    "level": -2147483648,
    "proto": 0,
    "predecessor": "string",
    "timestamp": "string",
    "validation_pass": 0,
    "operations_hash": "string",
    "fitness": [
      "string"
    ],
    "context": "string",
    "protocol_data": "string"
  },
  "operations": [
    [
      {
        "branch": "string",
        "data": "string"
      }
    ]
  ]
}

GET

https://xtz.nownodes.io/monitor/bootstrapped

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Wait for the node to have synchronized its chain with a few peers (configured by the node's administrator), streaming head updates that happen during the bootstrapping process, and closing the stream at the end. If the node was already bootstrapped, returns the current head immediately.

Response

200OK

Valid response

default

GET /monitor/bootstrapped

curl -X GET 'https://xtz.nownodes.io/monitor/bootstrapped'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/monitor/bootstrapped')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/monitor/bootstrapped')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/monitor/bootstrapped";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/monitor/bootstrapped')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/monitor/bootstrapped')
request = Net::HTTP::Get.new(uri)

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

200

{
  "block": "string",
  "timestamp": "string"
}

GET

https://xtz.nownodes.io/monitor/commit_hash

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

DEPRECATED: use version instead.

Response

200OK

Valid response

default

GET /monitor/commit_hash

curl -X GET 'https://xtz.nownodes.io/monitor/commit_hash'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/monitor/commit_hash')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/monitor/commit_hash')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/monitor/commit_hash";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/monitor/commit_hash')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/monitor/commit_hash')
request = Net::HTTP::Get.new(uri)

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

200

"string"

GET

https://xtz.nownodes.io/monitor/heads/{chain_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Monitor all blocks that are successfully validated and applied by the node and selected as the new head of the given chain.

Parameters

chain_idstringrequiredpath

A chain identifier. This is either a chain hash in Base58Check notation or a one the predefined aliases: 'main', 'test'.

protocolstringquery

Protocol_hash (Base58Check-encoded)

next_protocolstringquery

Protocol_hash (Base58Check-encoded)

Response

200OK

Valid response

default

GET /monitor/heads/{chain_id}

curl -X GET 'https://xtz.nownodes.io/monitor/heads/{chain_id}'

const response = await fetch('https://xtz.nownodes.io/monitor/heads/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/monitor/heads/{chain_id}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/monitor/heads/{chain_id}')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/monitor/heads/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/monitor/heads/{chain_id}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/monitor/heads/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/monitor/heads/{chain_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/monitor/heads/{chain_id}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "hash": "string",
  "level": -2147483648,
  "proto": 0,
  "predecessor": "string",
  "timestamp": "string",
  "validation_pass": 0,
  "operations_hash": "string",
  "fitness": [
    "string"
  ],
  "context": "string",
  "protocol_data": "string"
}

GET

https://xtz.nownodes.io/monitor/protocols

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Monitor all economic protocols that are retrieved and successfully loaded and compiled by the node.

Response

200OK

Valid response

default

GET /monitor/protocols

curl -X GET 'https://xtz.nownodes.io/monitor/protocols'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/monitor/protocols')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/monitor/protocols')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/monitor/protocols";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/monitor/protocols')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/monitor/protocols')
request = Net::HTTP::Get.new(uri)

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

200

"string"

GET

https://xtz.nownodes.io/monitor/validated_blocks

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Monitor all blocks that were successfully validated by the node but are not applied nor stored yet, disregarding whether they are going to be selected as the new head or not.

Parameters

protocolstringquery

Protocol_hash (Base58Check-encoded)

next_protocolstringquery

Protocol_hash (Base58Check-encoded)

chainstringquery

A chain identifier. This is either a chain hash in Base58Check notation or a one the predefined aliases: 'main', 'test'.

Response

200OK

Valid response

default

GET /monitor/validated_blocks

curl -X GET 'https://xtz.nownodes.io/monitor/validated_blocks'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/monitor/validated_blocks')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/monitor/validated_blocks')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/monitor/validated_blocks";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/monitor/validated_blocks')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/monitor/validated_blocks')
request = Net::HTTP::Get.new(uri)

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

200

{
  "chain_id": "string",
  "hash": "string",
  "header": {
    "level": -2147483648,
    "proto": 0,
    "predecessor": "string",
    "timestamp": "string",
    "validation_pass": 0,
    "operations_hash": "string",
    "fitness": [
      "string"
    ],
    "context": "string",
    "protocol_data": "string"
  },
  "operations": [
    [
      {
        "branch": "string",
        "data": "string"
      }
    ]
  ]
}

Network

GET

https://xtz.nownodes.io/network/connections

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

List the running P2P connection.

Response

200OK

Valid response

default

GET /network/connections

curl -X GET 'https://xtz.nownodes.io/network/connections'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/connections')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/connections')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/connections";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/connections')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/connections')
request = Net::HTTP::Get.new(uri)

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

200

[
  {
    "incoming": true,
    "peer_id": "string",
    "id_point": {
      "addr": "string",
      "port": 0
    },
    "remote_socket_port": 0,
    "announced_version": {
      "chain_name": "string",
      "distributed_db_version": 0,
      "p2p_version": 0
    },
    "private": true,
    "local_metadata": {
      "disable_mempool": true,
      "private_node": true
    },
    "remote_metadata": {
      "disable_mempool": true,
      "private_node": true
    }
  }
]

GET

https://xtz.nownodes.io/network/connections/{peer_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Details about the current P2P connection to the given peer.

Parameters

peer_idstringrequiredpath

A cryptographic node identity (Base58Check-encoded)

Response

200OK

Valid response

default

GET /network/connections/{peer_id}

curl -X GET 'https://xtz.nownodes.io/network/connections/{peer_id}'

const response = await fetch('https://xtz.nownodes.io/network/connections/{peer_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/connections/{peer_id}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/connections/{peer_id}')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/connections/{peer_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/connections/{peer_id}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/network/connections/{peer_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/connections/{peer_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/connections/{peer_id}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "incoming": true,
  "peer_id": "string",
  "id_point": {
    "addr": "string",
    "port": 0
  },
  "remote_socket_port": 0,
  "announced_version": {
    "chain_name": "string",
    "distributed_db_version": 0,
    "p2p_version": 0
  },
  "private": true,
  "local_metadata": {
    "disable_mempool": true,
    "private_node": true
  },
  "remote_metadata": {
    "disable_mempool": true,
    "private_node": true
  }
}

GET

https://xtz.nownodes.io/network/greylist/clear

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

DEPRECATED: Clear all greylists tables. This will unban all addresses and peers automatically greylisted by the system. Use DELETE /network/greylist instead

Response

200OK

Valid response

default

GET /network/greylist/clear

curl -X GET 'https://xtz.nownodes.io/network/greylist/clear'

const response = await fetch('https://xtz.nownodes.io/network/greylist/clear', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/greylist/clear')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/greylist/clear')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/greylist/clear', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/greylist/clear";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/network/greylist/clear', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/greylist/clear')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/greylist/clear')
request = Net::HTTP::Get.new(uri)

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

200

{}

GET

https://xtz.nownodes.io/network/greylist/ips

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an object that contains a list of IP and the field "not_reliable_since". If the field "not_reliable_since" is None then the list contains the currently greylisted IP addresses. If the field "not_reliable_since" Contains a date, this means that the greylist has been overflowed and it is no more possible to obtain the exact list of greylisted IPs. Since the greylist of IP addresses has been design to work whatever his size, there is no security issue related to this overflow. Reinitialize the ACL structure by calling "delete /network/greylist" to get back this list reliable.

Response

200OK

Valid response

default

GET /network/greylist/ips

curl -X GET 'https://xtz.nownodes.io/network/greylist/ips'

const response = await fetch('https://xtz.nownodes.io/network/greylist/ips', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/greylist/ips')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/greylist/ips')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/greylist/ips', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/greylist/ips";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/network/greylist/ips', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/greylist/ips')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/greylist/ips')
request = Net::HTTP::Get.new(uri)

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

200

{
  "ips": [
    "string"
  ],
  "not_reliable_since": "string"
}

GET

https://xtz.nownodes.io/network/greylist/peers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

List of the last greylisted peers.

Response

200OK

Valid response

default

GET /network/greylist/peers

curl -X GET 'https://xtz.nownodes.io/network/greylist/peers'

const response = await fetch('https://xtz.nownodes.io/network/greylist/peers', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/greylist/peers')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/greylist/peers')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/greylist/peers', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/greylist/peers";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/network/greylist/peers', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/greylist/peers')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/greylist/peers')
request = Net::HTTP::Get.new(uri)

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

200

[
  "string"
]

GET

https://xtz.nownodes.io/network/log

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Stream of all network events

Response

200OK

Valid response

default

GET /network/log

curl -X GET 'https://xtz.nownodes.io/network/log'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/log')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/log')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/log";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/log')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/log')
request = Net::HTTP::Get.new(uri)

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

200

{
  "event": "too_few_connections"
}

GET

https://xtz.nownodes.io/network/peers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

List the peers the node ever met.

Parameters

filterstringquery

Response

200OK

Valid response

default

GET /network/peers

curl -X GET 'https://xtz.nownodes.io/network/peers'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/peers')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/peers')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/peers";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/peers')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/peers')
request = Net::HTTP::Get.new(uri)

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

200

[
  [
    "string"
  ]
]

GET

https://xtz.nownodes.io/network/peers/{peer_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Details about a given peer.

Parameters

peer_idstringrequiredpath

A cryptographic node identity (Base58Check-encoded)

Response

200OK

Valid response

default

GET /network/peers/{peer_id}

curl -X GET 'https://xtz.nownodes.io/network/peers/{peer_id}'

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/peers/{peer_id}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/peers/{peer_id}')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/peers/{peer_id}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/peers/{peer_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/peers/{peer_id}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "score": 0,
  "trusted": true,
  "conn_metadata": {
    "disable_mempool": true,
    "private_node": true
  },
  "peer_metadata": {
    "responses": {
      "sent": {
        "branch": "string",
        "head": "string",
        "block_header": "string",
        "operations": "string",
        "protocols": "string",
        "operation_hashes_for_block": "string",
        "operations_for_block": "string",
        "checkpoint": "string",
        "protocol_branch": "string",
        "predecessor_header": "string",
        "other": "string"
      },
      "failed": {
        "branch": "string",
        "head": "string",
        "block_header": "string",
        "operations": "string",
        "protocols": "string",
        "operation_hashes_for_block": "string",
        "operations_for_block": "string",
        "checkpoint": "string",
        "protocol_branch": "string",
        "predecessor_header": "string",
        "other": "string"
      },
      "received": {
        "branch": "string",
        "head": "string",
        "block_header": "string",
        "operations": "string",
        "protocols": "string",
        "operation_hashes_for_block": "string",
        "operations_for_block": "string",
        "checkpoint": "string",
        "protocol_branch": "string",
        "predecessor_header": "string",
        "other": "string"
      },
      "unexpected": "string",
      "outdated": "string"
    },
    "requests": {
      "sent": {
        "branch": "string",
        "head": "string",
        "block_header": "string",
        "operations": "string",
        "protocols": "string",
        "operation_hashes_for_block": "string",
        "operations_for_block": "string",
        "checkpoint": "string",
        "protocol_branch": "string",
        "predecessor_header": "string",
        "other": "string"
      },
      "received": {
        "branch": "string",
        "head": "string",
        "block_header": "string",
        "operations": "string",
        "protocols": "string",
        "operation_hashes_for_block": "string",
        "operations_for_block": "string",
        "checkpoint": "string",
        "protocol_branch": "string",
        "predecessor_header": "string",
        "other": "string"
      },
      "failed": {
        "branch": "string",
        "head": "string",
        "block_header": "string",
        "operations": "string",
        "protocols": "string",
        "operation_hashes_for_block": "string",
        "operations_for_block": "string",
        "checkpoint": "string",
        "protocol_branch": "string",
        "predecessor_header": "string",
        "other": "string"
      },
      "scheduled": {
        "branch": "string",
        "head": "string",
        "block_header": "string",
        "operations": "string",
        "protocols": "string",
        "operation_hashes_for_block": "string",
        "operations_for_block": "string",
        "checkpoint": "string",
        "protocol_branch": "string",
        "predecessor_header": "string",
        "other": "string"
      }
    },
    "valid_blocks": "string",
    "old_heads": "string",
    "prevalidator_results": {
      "cannot_download": "string",
      "cannot_parse": "string",
      "refused_by_prefilter": "string",
      "refused_by_postfilter": "string",
      "applied": "string",
      "branch_delayed": "string",
      "branch_refused": "string",
      "refused": "string",
      "duplicate": "string",
      "outdated": "string"
    },
    "unactivated_chains": "string",
    "inactive_chains": "string",
    "future_blocks_advertised": "string",
    "unadvertised": {
      "block": "string",
      "operations": "string",
      "protocol": "string"
    },
    "advertisements": {
      "sent": {
        "head": "string",
        "branch": "string"
      },
      "received": {
        "head": "string",
        "branch": "string"
      }
    }
  },
  "state": "running",
  "reachable_at": {
    "addr": "string",
    "port": 0
  },
  "stat": {
    "total_sent": "string",
    "total_recv": "string",
    "current_inflow": -1073741824,
    "current_outflow": -1073741824
  },
  "last_failed_connection": [
    {
      "addr": "string",
      "port": 0
    }
  ],
  "last_rejected_connection": [
    {
      "addr": "string",
      "port": 0
    }
  ],
  "last_established_connection": [
    {
      "addr": "string",
      "port": 0
    }
  ],
  "last_disconnection": [
    {
      "addr": "string",
      "port": 0
    }
  ],
  "last_seen": [
    {
      "addr": "string",
      "port": 0
    }
  ],
  "last_miss": [
    {
      "addr": "string",
      "port": 0
    }
  ]
}

GET

https://xtz.nownodes.io/network/peers/{peer_id}/ban

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

DEPRECATED: Blacklist the given peer and remove it from the whitelist if present. Use PATCH network/peers/<peer_id> instead.

Parameters

peer_idstringrequiredpath

A cryptographic node identity (Base58Check-encoded)

Response

200OK

Valid response

default

GET /network/peers/{peer_id}/ban

curl -X GET 'https://xtz.nownodes.io/network/peers/{peer_id}/ban'

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}/ban', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/peers/{peer_id}/ban')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/peers/{peer_id}/ban')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}/ban', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/peers/{peer_id}/ban";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}/ban', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/peers/{peer_id}/ban')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/peers/{peer_id}/ban')
request = Net::HTTP::Get.new(uri)

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

200

{}

GET

https://xtz.nownodes.io/network/peers/{peer_id}/banned

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Check if a given peer is blacklisted or greylisted.

Parameters

peer_idstringrequiredpath

A cryptographic node identity (Base58Check-encoded)

Response

200OK

Valid response

default

GET /network/peers/{peer_id}/banned

curl -X GET 'https://xtz.nownodes.io/network/peers/{peer_id}/banned'

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}/banned', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/peers/{peer_id}/banned')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/peers/{peer_id}/banned')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}/banned', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/peers/{peer_id}/banned";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}/banned', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/peers/{peer_id}/banned')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/peers/{peer_id}/banned')
request = Net::HTTP::Get.new(uri)

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

200

true

GET

https://xtz.nownodes.io/network/peers/{peer_id}/log

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Monitor network events related to a given peer.

Parameters

peer_idstringrequiredpath

A cryptographic node identity (Base58Check-encoded)

monitorstringquery

Response

200OK

Valid response

default

GET /network/peers/{peer_id}/log

curl -X GET 'https://xtz.nownodes.io/network/peers/{peer_id}/log'

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}/log', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/peers/{peer_id}/log')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/peers/{peer_id}/log')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}/log', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/peers/{peer_id}/log";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}/log', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/peers/{peer_id}/log')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/peers/{peer_id}/log')
request = Net::HTTP::Get.new(uri)

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

200

[
  {
    "kind": "rejecting_request",
    "timestamp": "string",
    "addr": "string",
    "port": 0
  }
]

GET

https://xtz.nownodes.io/network/peers/{peer_id}/trust

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

DEPRECATED: Whitelist a given peer permanently and remove it from the blacklist if present. The peer cannot be blocked (but its host IP still can). Use PATCH network/peers/<peer_id> instead.

Parameters

peer_idstringrequiredpath

A cryptographic node identity (Base58Check-encoded)

Response

200OK

Valid response

default

GET /network/peers/{peer_id}/trust

curl -X GET 'https://xtz.nownodes.io/network/peers/{peer_id}/trust'

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}/trust', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/peers/{peer_id}/trust')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/peers/{peer_id}/trust')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}/trust', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/peers/{peer_id}/trust";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}/trust', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/peers/{peer_id}/trust')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/peers/{peer_id}/trust')
request = Net::HTTP::Get.new(uri)

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

200

{}

GET

https://xtz.nownodes.io/network/peers/{peer_id}/unban

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

DEPRECATED: Remove the given peer from the blacklist. Use PATCH network/peers/<peer_id> instead.

Parameters

peer_idstringrequiredpath

A cryptographic node identity (Base58Check-encoded)

Response

200OK

Valid response

default

GET /network/peers/{peer_id}/unban

curl -X GET 'https://xtz.nownodes.io/network/peers/{peer_id}/unban'

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}/unban', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/peers/{peer_id}/unban')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/peers/{peer_id}/unban')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}/unban', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/peers/{peer_id}/unban";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}/unban', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/peers/{peer_id}/unban')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/peers/{peer_id}/unban')
request = Net::HTTP::Get.new(uri)

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

200

{}

GET

https://xtz.nownodes.io/network/peers/{peer_id}/untrust

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

DEPRECATED: Remove a given peer from the whitelist. Use PATCH network/peers/<peer_id> instead.

Parameters

peer_idstringrequiredpath

A cryptographic node identity (Base58Check-encoded)

Response

200OK

Valid response

default

GET /network/peers/{peer_id}/untrust

curl -X GET 'https://xtz.nownodes.io/network/peers/{peer_id}/untrust'

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}/untrust', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/peers/{peer_id}/untrust')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/peers/{peer_id}/untrust')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}/untrust', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/peers/{peer_id}/untrust";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}/untrust', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/peers/{peer_id}/untrust')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/peers/{peer_id}/untrust')
request = Net::HTTP::Get.new(uri)

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

200

{}

GET

https://xtz.nownodes.io/network/points

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

List the pool of known IP:port used for establishing P2P connections.

Parameters

filterstringquery

Response

200OK

Valid response

default

GET /network/points

curl -X GET 'https://xtz.nownodes.io/network/points'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/points')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/points')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/points";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/points')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/points')
request = Net::HTTP::Get.new(uri)

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

200

[
  [
    "string"
  ]
]

GET

https://xtz.nownodes.io/network/points/{point}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Details about a given IP:addr.

Parameters

pointstringrequiredpath

A network point (ipv4:port or [ipv6]:port).

Response

200OK

Valid response

default

GET /network/points/{point}

curl -X GET 'https://xtz.nownodes.io/network/points/{point}'

const response = await fetch('https://xtz.nownodes.io/network/points/{point}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/points/{point}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/points/{point}')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/points/{point}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/points/{point}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/network/points/{point}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/points/{point}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/points/{point}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "trusted": true,
  "greylisted_until": "string",
  "state": {
    "event_kind": "requested"
  },
  "p2p_peer_id": "string",
  "last_failed_connection": "string",
  "last_rejected_connection": [
    "string"
  ],
  "last_established_connection": [
    "string"
  ],
  "last_disconnection": [
    "string"
  ],
  "last_seen": [
    "string"
  ],
  "last_miss": "string",
  "expected_peer_id": "string"
}

GET

https://xtz.nownodes.io/network/points/{point}/ban

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

DEPRECATED: Blacklist the given address and remove it from the whitelist if present. Use PATCH /network/point/<point_id> instead.

Parameters

pointstringrequiredpath

A network point (ipv4:port or [ipv6]:port).

Response

200OK

Valid response

default

GET /network/points/{point}/ban

curl -X GET 'https://xtz.nownodes.io/network/points/{point}/ban'

const response = await fetch('https://xtz.nownodes.io/network/points/{point}/ban', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/points/{point}/ban')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/points/{point}/ban')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/points/{point}/ban', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/points/{point}/ban";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/network/points/{point}/ban', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/points/{point}/ban')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/points/{point}/ban')
request = Net::HTTP::Get.new(uri)

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

200

{}

GET

https://xtz.nownodes.io/network/points/{point}/banned

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Check if a given address is blacklisted or greylisted. Port component is unused.

Parameters

pointstringrequiredpath

A network point (ipv4:port or [ipv6]:port).

Response

200OK

Valid response

default

GET /network/points/{point}/banned

curl -X GET 'https://xtz.nownodes.io/network/points/{point}/banned'

const response = await fetch('https://xtz.nownodes.io/network/points/{point}/banned', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/points/{point}/banned')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/points/{point}/banned')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/points/{point}/banned', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/points/{point}/banned";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/network/points/{point}/banned', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/points/{point}/banned')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/points/{point}/banned')
request = Net::HTTP::Get.new(uri)

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

200

true

GET

https://xtz.nownodes.io/network/points/{point}/log

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Monitor network events related to an IP:addr.

Parameters

pointstringrequiredpath

A network point (ipv4:port or [ipv6]:port).

monitorstringquery

Response

200OK

Valid response

default

GET /network/points/{point}/log

curl -X GET 'https://xtz.nownodes.io/network/points/{point}/log'

const response = await fetch('https://xtz.nownodes.io/network/points/{point}/log', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/points/{point}/log')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/points/{point}/log')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/points/{point}/log', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/points/{point}/log";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/network/points/{point}/log', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/points/{point}/log')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/points/{point}/log')
request = Net::HTTP::Get.new(uri)

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

200

[
  [
    "string"
  ]
]

GET

https://xtz.nownodes.io/network/points/{point}/trust

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

DEPRECATED: Trust a given address permanently and remove it from the blacklist if present. Connections from this address can still be closed on authentication if the peer is greylisted. Use PATCH/network/point/<point_id> instead.

Parameters

pointstringrequiredpath

A network point (ipv4:port or [ipv6]:port).

Response

200OK

Valid response

default

GET /network/points/{point}/trust

curl -X GET 'https://xtz.nownodes.io/network/points/{point}/trust'

const response = await fetch('https://xtz.nownodes.io/network/points/{point}/trust', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/points/{point}/trust')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/points/{point}/trust')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/points/{point}/trust', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/points/{point}/trust";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/network/points/{point}/trust', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/points/{point}/trust')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/points/{point}/trust')
request = Net::HTTP::Get.new(uri)

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

200

{}

GET

https://xtz.nownodes.io/network/points/{point}/unban

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

DEPRECATED: Remove an address from the blacklist. Use PATCH /network/point/<point_id> instead.

Parameters

pointstringrequiredpath

A network point (ipv4:port or [ipv6]:port).

Response

200OK

Valid response

default

GET /network/points/{point}/unban

curl -X GET 'https://xtz.nownodes.io/network/points/{point}/unban'

const response = await fetch('https://xtz.nownodes.io/network/points/{point}/unban', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/points/{point}/unban')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/points/{point}/unban')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/points/{point}/unban', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/points/{point}/unban";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/network/points/{point}/unban', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/points/{point}/unban')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/points/{point}/unban')
request = Net::HTTP::Get.new(uri)

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

200

{}

GET

https://xtz.nownodes.io/network/points/{point}/untrust

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

DEPRECATED: Remove an address from the whitelist. Use PATCH /network/point/<point_id> instead.

Parameters

pointstringrequiredpath

A network point (ipv4:port or [ipv6]:port).

Response

200OK

Valid response

default

GET /network/points/{point}/untrust

curl -X GET 'https://xtz.nownodes.io/network/points/{point}/untrust'

const response = await fetch('https://xtz.nownodes.io/network/points/{point}/untrust', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/points/{point}/untrust')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/points/{point}/untrust')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/points/{point}/untrust', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/points/{point}/untrust";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/network/points/{point}/untrust', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/points/{point}/untrust')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/points/{point}/untrust')
request = Net::HTTP::Get.new(uri)

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

200

{}

GET

https://xtz.nownodes.io/network/self

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Return the node's peer id

Response

200OK

Valid response

default

GET /network/self

curl -X GET 'https://xtz.nownodes.io/network/self'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/self')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/self')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/self";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/self')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/self')
request = Net::HTTP::Get.new(uri)

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

200

"string"

GET

https://xtz.nownodes.io/network/stat

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Global network bandwidth statistics in B/s.

Response

200OK

Valid response

default

GET /network/stat

curl -X GET 'https://xtz.nownodes.io/network/stat'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/stat')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/stat')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/stat";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/stat')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/stat')
request = Net::HTTP::Get.new(uri)

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

200

{
  "total_sent": "string",
  "total_recv": "string",
  "current_inflow": -1073741824,
  "current_outflow": -1073741824
}

GET

https://xtz.nownodes.io/network/version

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

DEPRECATED: use version instead.

Response

200OK

Valid response

default

GET /network/version

curl -X GET 'https://xtz.nownodes.io/network/version'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/version')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/version')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/version";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/version')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/version')
request = Net::HTTP::Get.new(uri)

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

200

{
  "chain_name": "string",
  "distributed_db_version": 0,
  "p2p_version": 0
}

GET

https://xtz.nownodes.io/network/versions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

DEPRECATED: use version instead.

Response

200OK

Valid response

default

GET /network/versions

curl -X GET 'https://xtz.nownodes.io/network/versions'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/versions')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/network/versions')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/versions";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/network/versions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/versions')
request = Net::HTTP::Get.new(uri)

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

200

[
  {
    "chain_name": "string",
    "distributed_db_version": 0,
    "p2p_version": 0
  }
]

default

PATCH

https://xtz.nownodes.io/network/peers/{peer_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Change the permissions of a given peer. With {acl: ban}: blacklist the given peer and remove it from the whitelist if present. With {acl: open}: removes the peer from the blacklist and whitelist. With {acl: trust}: trust the given peer permanently and remove it from the blacklist if present. The peer cannot be blocked (but its host IP still can).

Body

application/json

aclstringopentrustban

Parameters

peer_idstringrequiredpath

A cryptographic node identity (Base58Check-encoded)

Response

200OK

Valid response

default

PATCH /network/peers/{peer_id}

curl -X PATCH 'https://xtz.nownodes.io/network/peers/{peer_id}' \
  -H 'Content-Type: application/json' \
  -d '{
    "acl": "open"
  }'

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}', {
  method: 'PATCH',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "acl": "open"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/peers/{peer_id}')
request = Net::HTTP::Patch.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "acl": "open"
  }'

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

import requests

payload = {
  "acl": "open"
}

response = requests.patch('https://xtz.nownodes.io/network/peers/{peer_id}', json=payload)
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}', {
  method: 'PATCH',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "acl": "open"
    }),
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/peers/{peer_id}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "acl": "open"
  });
console.log(result);

const response = await fetch('https://xtz.nownodes.io/network/peers/{peer_id}', {
  method: 'PATCH',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "acl": "open"
    }),
});

const data = await response.json();

import requests

payload = {
  "acl": "open"
}

response = requests.patch('https://xtz.nownodes.io/network/peers/{peer_id}', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/peers/{peer_id}')
request = Net::HTTP::Patch.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "acl": "open"
  }'

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

Request Body

{
  "acl": "open"
}

200

{
  "score": 0,
  "trusted": true,
  "conn_metadata": {
    "disable_mempool": true,
    "private_node": true
  },
  "peer_metadata": {
    "responses": {
      "sent": {
        "branch": "string",
        "head": "string",
        "block_header": "string",
        "operations": "string",
        "protocols": "string",
        "operation_hashes_for_block": "string",
        "operations_for_block": "string",
        "checkpoint": "string",
        "protocol_branch": "string",
        "predecessor_header": "string",
        "other": "string"
      },
      "failed": {
        "branch": "string",
        "head": "string",
        "block_header": "string",
        "operations": "string",
        "protocols": "string",
        "operation_hashes_for_block": "string",
        "operations_for_block": "string",
        "checkpoint": "string",
        "protocol_branch": "string",
        "predecessor_header": "string",
        "other": "string"
      },
      "received": {
        "branch": "string",
        "head": "string",
        "block_header": "string",
        "operations": "string",
        "protocols": "string",
        "operation_hashes_for_block": "string",
        "operations_for_block": "string",
        "checkpoint": "string",
        "protocol_branch": "string",
        "predecessor_header": "string",
        "other": "string"
      },
      "unexpected": "string",
      "outdated": "string"
    },
    "requests": {
      "sent": {
        "branch": "string",
        "head": "string",
        "block_header": "string",
        "operations": "string",
        "protocols": "string",
        "operation_hashes_for_block": "string",
        "operations_for_block": "string",
        "checkpoint": "string",
        "protocol_branch": "string",
        "predecessor_header": "string",
        "other": "string"
      },
      "received": {
        "branch": "string",
        "head": "string",
        "block_header": "string",
        "operations": "string",
        "protocols": "string",
        "operation_hashes_for_block": "string",
        "operations_for_block": "string",
        "checkpoint": "string",
        "protocol_branch": "string",
        "predecessor_header": "string",
        "other": "string"
      },
      "failed": {
        "branch": "string",
        "head": "string",
        "block_header": "string",
        "operations": "string",
        "protocols": "string",
        "operation_hashes_for_block": "string",
        "operations_for_block": "string",
        "checkpoint": "string",
        "protocol_branch": "string",
        "predecessor_header": "string",
        "other": "string"
      },
      "scheduled": {
        "branch": "string",
        "head": "string",
        "block_header": "string",
        "operations": "string",
        "protocols": "string",
        "operation_hashes_for_block": "string",
        "operations_for_block": "string",
        "checkpoint": "string",
        "protocol_branch": "string",
        "predecessor_header": "string",
        "other": "string"
      }
    },
    "valid_blocks": "string",
    "old_heads": "string",
    "prevalidator_results": {
      "cannot_download": "string",
      "cannot_parse": "string",
      "refused_by_prefilter": "string",
      "refused_by_postfilter": "string",
      "applied": "string",
      "branch_delayed": "string",
      "branch_refused": "string",
      "refused": "string",
      "duplicate": "string",
      "outdated": "string"
    },
    "unactivated_chains": "string",
    "inactive_chains": "string",
    "future_blocks_advertised": "string",
    "unadvertised": {
      "block": "string",
      "operations": "string",
      "protocol": "string"
    },
    "advertisements": {
      "sent": {
        "head": "string",
        "branch": "string"
      },
      "received": {
        "head": "string",
        "branch": "string"
      }
    }
  },
  "state": "running",
  "reachable_at": {
    "addr": "string",
    "port": 0
  },
  "stat": {
    "total_sent": "string",
    "total_recv": "string",
    "current_inflow": -1073741824,
    "current_outflow": -1073741824
  },
  "last_failed_connection": [
    {
      "addr": "string",
      "port": 0
    }
  ],
  "last_rejected_connection": [
    {
      "addr": "string",
      "port": 0
    }
  ],
  "last_established_connection": [
    {
      "addr": "string",
      "port": 0
    }
  ],
  "last_disconnection": [
    {
      "addr": "string",
      "port": 0
    }
  ],
  "last_seen": [
    {
      "addr": "string",
      "port": 0
    }
  ],
  "last_miss": [
    {
      "addr": "string",
      "port": 0
    }
  ]
}

PATCH

https://xtz.nownodes.io/network/points/{point}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Change the connectivity state of a given IP:addr. With {acl : ban}: blacklist the given address and remove it from the whitelist if present. With {acl: open}: removes an address from the blacklist and whitelist. With {acl: trust}: trust a given address permanently and remove it from the blacklist if present. With {peer_id: <id>} set the peerId of the point. Connections from this address can still be closed on authentication if the peer is greylisted.

Body

application/json

aclstringopentrustban

peer_idstring | object

Parameters

pointstringrequiredpath

A network point (ipv4:port or [ipv6]:port).

Response

200OK

Valid response

default

PATCH /network/points/{point}

curl -X PATCH 'https://xtz.nownodes.io/network/points/{point}' \
  -H 'Content-Type: application/json' \
  -d '{
    "acl": "open",
    "peer_id": "string"
  }'

const response = await fetch('https://xtz.nownodes.io/network/points/{point}', {
  method: 'PATCH',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "acl": "open",
      "peer_id": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/points/{point}')
request = Net::HTTP::Patch.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "acl": "open",
    "peer_id": "string"
  }'

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

import requests

payload = {
  "acl": "open",
  "peer_id": "string"
}

response = requests.patch('https://xtz.nownodes.io/network/points/{point}', json=payload)
data = response.json()

const response = await fetch('https://xtz.nownodes.io/network/points/{point}', {
  method: 'PATCH',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "acl": "open",
      "peer_id": "string"
    }),
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/network/points/{point}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "acl": "open",
    "peer_id": "string"
  });
console.log(result);

const response = await fetch('https://xtz.nownodes.io/network/points/{point}', {
  method: 'PATCH',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "acl": "open",
      "peer_id": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "acl": "open",
  "peer_id": "string"
}

response = requests.patch('https://xtz.nownodes.io/network/points/{point}', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/network/points/{point}')
request = Net::HTTP::Patch.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "acl": "open",
    "peer_id": "string"
  }'

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

Request Body

{
  "acl": "open",
  "peer_id": "string"
}

200

{
  "trusted": true,
  "greylisted_until": "string",
  "state": {
    "event_kind": "requested"
  },
  "p2p_peer_id": "string",
  "last_failed_connection": "string",
  "last_rejected_connection": [
    "string"
  ],
  "last_established_connection": [
    "string"
  ],
  "last_disconnection": [
    "string"
  ],
  "last_seen": [
    "string"
  ],
  "last_miss": "string",
  "expected_peer_id": "string"
}

Protocols

GET

https://xtz.nownodes.io/protocols

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

(no description)

Response

200OK

Valid response

default

GET /protocols

curl -X GET 'https://xtz.nownodes.io/protocols'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

response = requests.get('https://xtz.nownodes.io/protocols')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/protocols";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/protocols')
data = response.json()

require 'net/http'
require 'json'

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

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

200

[
  "string"
]

GET

https://xtz.nownodes.io/protocols/{Protocol_hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

(no description)

Parameters

Protocol_hashstringrequiredpath

Protocol_hash (Base58Check-encoded)

Response

200OK

Valid response

default

GET /protocols/{Protocol_hash}

curl -X GET 'https://xtz.nownodes.io/protocols/{Protocol_hash}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/protocols/{Protocol_hash}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/protocols/{Protocol_hash}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/protocols/{Protocol_hash}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/protocols/{Protocol_hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/protocols/{Protocol_hash}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "expected_env_version": 0,
  "components": [
    {
      "name": "string",
      "interface": "string",
      "implementation": "string"
    }
  ]
}

GET

https://xtz.nownodes.io/protocols/{Protocol_hash}/environment

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

(no description)

Parameters

Protocol_hashstringrequiredpath

Protocol_hash (Base58Check-encoded)

Response

200OK

Valid response

default

GET /protocols/{Protocol_hash}/environment

curl -X GET 'https://xtz.nownodes.io/protocols/{Protocol_hash}/environment'

const response = await fetch('https://xtz.nownodes.io/protocols/{Protocol_hash}/environment', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/protocols/{Protocol_hash}/environment')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/protocols/{Protocol_hash}/environment')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/protocols/{Protocol_hash}/environment', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/protocols/{Protocol_hash}/environment";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/protocols/{Protocol_hash}/environment', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/protocols/{Protocol_hash}/environment')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/protocols/{Protocol_hash}/environment')
request = Net::HTTP::Get.new(uri)

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

200

Stats

GET

https://xtz.nownodes.io/stats/gc

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Gets stats from the OCaml Garbage Collector

Response

200OK

Valid response

default

GET /stats/gc

curl -X GET 'https://xtz.nownodes.io/stats/gc'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/stats/gc')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/stats/gc')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/stats/gc";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/stats/gc')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/stats/gc')
request = Net::HTTP::Get.new(uri)

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

200

{
  "minor_words": 0,
  "promoted_words": 0,
  "major_words": 0,
  "minor_collections": -1073741824,
  "major_collections": -1073741824,
  "forced_major_collections": -1073741824,
  "heap_words": -1073741824,
  "heap_chunks": -1073741824,
  "live_words": -1073741824,
  "live_blocks": -1073741824,
  "free_words": -1073741824,
  "free_blocks": -1073741824,
  "largest_free": -1073741824,
  "fragments": -1073741824,
  "compactions": -1073741824,
  "top_heap_words": -1073741824,
  "stack_size": -1073741824
}

GET

https://xtz.nownodes.io/stats/memory

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Gets memory usage stats

Response

200OK

Valid response

default

GET /stats/memory

curl -X GET 'https://xtz.nownodes.io/stats/memory'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/stats/memory')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/stats/memory')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/stats/memory";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/stats/memory')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/stats/memory')
request = Net::HTTP::Get.new(uri)

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

200

{
  "page_size": -1073741824,
  "size": "string",
  "resident": "string",
  "shared": "string",
  "text": "string",
  "lib": "string",
  "data": "string",
  "dt": "string"
}

Version

GET

https://xtz.nownodes.io/version

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get information on the node version

Response

200OK

Valid response

default

GET /version

curl -X GET 'https://xtz.nownodes.io/version'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

response = requests.get('https://xtz.nownodes.io/version')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/version";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/version')
data = response.json()

require 'net/http'
require 'json'

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

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

200

{
  "version": {
    "major": -1073741824,
    "minor": -1073741824,
    "additional_info": "dev"
  },
  "network_version": {
    "chain_name": "string",
    "distributed_db_version": 0,
    "p2p_version": 0
  },
  "commit_info": {
    "commit_hash": "string",
    "commit_date": "string"
  }
}

Workers

GET

https://xtz.nownodes.io/workers/block_validator

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Introspect the state of the block_validator worker.

Response

200OK

Valid response

default

GET /workers/block_validator

curl -X GET 'https://xtz.nownodes.io/workers/block_validator'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/workers/block_validator')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/workers/block_validator')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/workers/block_validator";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/workers/block_validator')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/workers/block_validator')
request = Net::HTTP::Get.new(uri)

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

200

{
  "status": {
    "phase": "launching",
    "since": "string"
  },
  "pending_requests": [
    {
      "pushed": "string",
      "request": {
        "block": "string",
        "chain_id": "string",
        "peer": "string"
      }
    }
  ],
  "current_request": {
    "pushed": "string",
    "treated": "string",
    "request": {
      "block": "string",
      "chain_id": "string",
      "peer": "string"
    }
  }
}

GET

https://xtz.nownodes.io/workers/chain_validators

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Lists the chain validator workers and their status.

Response

200OK

Valid response

default

GET /workers/chain_validators

curl -X GET 'https://xtz.nownodes.io/workers/chain_validators'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/workers/chain_validators')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/workers/chain_validators')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/workers/chain_validators";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/workers/chain_validators')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/workers/chain_validators')
request = Net::HTTP::Get.new(uri)

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

200

[
  {
    "chain_id": "string",
    "status": {
      "phase": "launching",
      "since": "string"
    },
    "information": {
      "instances": -1073741824,
      "status": {
        "phase": "launching",
        "since": "string"
      },
      "queue_length": -1073741824
    },
    "pipelines": -32768
  }
]

GET

https://xtz.nownodes.io/workers/chain_validators/{chain_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Introspect the state of a chain validator worker.

Parameters

chain_idstringrequiredpath

A chain identifier. This is either a chain hash in Base58Check notation or a one the predefined aliases: 'main', 'test'.

Response

200OK

Valid response

default

GET /workers/chain_validators/{chain_id}

curl -X GET 'https://xtz.nownodes.io/workers/chain_validators/{chain_id}'

const response = await fetch('https://xtz.nownodes.io/workers/chain_validators/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/workers/chain_validators/{chain_id}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/workers/chain_validators/{chain_id}')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/workers/chain_validators/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/workers/chain_validators/{chain_id}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/workers/chain_validators/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/workers/chain_validators/{chain_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/workers/chain_validators/{chain_id}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "status": {
    "phase": "launching",
    "since": "string"
  },
  "pending_requests": [
    {
      "pushed": "string",
      "request": {
        "hash": "string"
      }
    }
  ],
  "current_request": {
    "pushed": "string",
    "treated": "string",
    "request": {
      "hash": "string"
    }
  }
}

GET

https://xtz.nownodes.io/workers/chain_validators/{chain_id}/ddb

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Introspect the state of the DDB attached to a chain validator worker.

Parameters

chain_idstringrequiredpath

A chain identifier. This is either a chain hash in Base58Check notation or a one the predefined aliases: 'main', 'test'.

Response

200OK

Valid response

default

GET /workers/chain_validators/{chain_id}/ddb

curl -X GET 'https://xtz.nownodes.io/workers/chain_validators/{chain_id}/ddb'

const response = await fetch('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/ddb', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/ddb')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/ddb')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/ddb', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/workers/chain_validators/{chain_id}/ddb";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/ddb', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/ddb')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/ddb')
request = Net::HTTP::Get.new(uri)

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

200

{
  "p2p_readers": -1073741824,
  "active_chains": -1073741824,
  "operation_db": {
    "table_length": -1073741824,
    "scheduler_length": -1073741824
  },
  "operations_db": {
    "table_length": -1073741824,
    "scheduler_length": -1073741824
  },
  "block_header_db": {
    "table_length": -1073741824,
    "scheduler_length": -1073741824
  },
  "active_connections": -1073741824,
  "active_peers": -1073741824
}

GET

https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Lists the peer validator workers and their status.

Parameters

chain_idstringrequiredpath

A chain identifier. This is either a chain hash in Base58Check notation or a one the predefined aliases: 'main', 'test'.

Response

200OK

Valid response

default

GET /workers/chain_validators/{chain_id}/peers_validators

curl -X GET 'https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators'

const response = await fetch('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators')
request = Net::HTTP::Get.new(uri)

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

200

[
  {
    "peer_id": "string",
    "status": {
      "phase": "launching",
      "since": "string"
    },
    "information": {
      "instances": -1073741824,
      "status": {
        "phase": "launching",
        "since": "string"
      },
      "queue_length": -1073741824
    },
    "pipelines": {
      "fetched_headers": -1073741824,
      "fetched_blocks": -1073741824
    }
  }
]

GET

https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators/{peer_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Introspect the state of a peer validator worker.

Parameters

chain_idstringrequiredpath

A chain identifier. This is either a chain hash in Base58Check notation or a one the predefined aliases: 'main', 'test'.

peer_idstringrequiredpath

A cryptographic node identity (Base58Check-encoded)

Response

200OK

Valid response

default

GET /workers/chain_validators/{chain_id}/peers_validators/{peer_id}

curl -X GET 'https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators/{peer_id}'

const response = await fetch('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators/{peer_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators/{peer_id}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators/{peer_id}')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators/{peer_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators/{peer_id}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators/{peer_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators/{peer_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/workers/chain_validators/{chain_id}/peers_validators/{peer_id}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "status": {
    "phase": "launching",
    "since": "string"
  },
  "pending_requests": [
    {
      "pushed": "string",
      "request": {
        "request": "new_head",
        "block": "string"
      }
    }
  ],
  "current_request": {
    "pushed": "string",
    "treated": "string",
    "request": {
      "request": "new_head",
      "block": "string"
    }
  }
}

GET

https://xtz.nownodes.io/workers/prevalidators

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Lists the Prevalidator workers and their status.

Response

200OK

Valid response

default

GET /workers/prevalidators

curl -X GET 'https://xtz.nownodes.io/workers/prevalidators'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/workers/prevalidators')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/workers/prevalidators')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/workers/prevalidators";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/workers/prevalidators')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/workers/prevalidators')
request = Net::HTTP::Get.new(uri)

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

200

[
  {
    "chain_id": "string",
    "status": {
      "phase": "launching",
      "since": "string"
    },
    "information": {
      "instances": -1073741824,
      "status": {
        "phase": "launching",
        "since": "string"
      },
      "queue_length": -1073741824
    },
    "pipelines": -32768
  }
]

GET

https://xtz.nownodes.io/workers/prevalidators/{chain_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Introspect the state of prevalidator workers.

Parameters

chain_idstringrequiredpath

A chain identifier. This is either a chain hash in Base58Check notation or a one the predefined aliases: 'main', 'test'.

Response

200OK

Valid response

default

GET /workers/prevalidators/{chain_id}

curl -X GET 'https://xtz.nownodes.io/workers/prevalidators/{chain_id}'

const response = await fetch('https://xtz.nownodes.io/workers/prevalidators/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/workers/prevalidators/{chain_id}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz.nownodes.io/workers/prevalidators/{chain_id}')
data = response.json()

const response = await fetch('https://xtz.nownodes.io/workers/prevalidators/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz.nownodes.io/workers/prevalidators/{chain_id}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz.nownodes.io/workers/prevalidators/{chain_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz.nownodes.io/workers/prevalidators/{chain_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz.nownodes.io/workers/prevalidators/{chain_id}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "status": {
    "phase": "launching",
    "since": "string"
  },
  "pending_requests": [
    {
      "pushed": "string",
      "request": {
        "request": "flush",
        "block": "string",
        "event": "branch"
      }
    }
  ],
  "current_request": {
    "pushed": "string",
    "treated": "string",
    "request": {
      "request": "flush",
      "block": "string",
      "event": "branch"
    }
  }
}

Documentation

How to migrate to NOWNodes

Authentication

Node

Chains

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Config

Authorizations

Response

Authorizations

Response

Authorizations

Response

Authorizations

Response

Authorizations

Response

Errors

Authorizations

Response

Fetch_protocol

Authorizations

Parameters

Response

Injection

Authorizations

Body

Parameters

Response

Authorizations

Body

Parameters

Response

Authorizations

Body

Parameters

Response

Monitor

Authorizations

Response

Authorizations

Parameters

Response

Authorizations

Response

Authorizations

Response

Authorizations

Parameters

Response

Authorizations

Response

Authorizations

Parameters