NEM NIS API

v1.0.0

Base URL

https://xem.nownodes.io

Version 1.19

19:27, March 20, 2017

http://bob.nem.ninja/docs/

Authentication

api-keyAuthapiKey

API Key: api-key in header

Node

Heartbeat

Heart beat

GET

https://xem.nownodes.io/heartbeat

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Heart beat

Response

200OK

Heart beat

curl -X GET 'https://xem.nownodes.io/heartbeat'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/heartbeat')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/heartbeat')
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)

Status

GET

https://xem.nownodes.io/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Status

Response

200OK

Status

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

Account

Retrieving account data

GET

https://xem.nownodes.io/account/generate

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieving account data

Response

200OK

Retrieving account data

curl -X GET 'https://xem.nownodes.io/account/generate'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/generate')
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://xem.nownodes.io/account/generate')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/account/generate')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/generate')
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)

Requesting the account data

GET

https://xem.nownodes.io/account/get

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Requesting the account data

Parameters

addressstringquery

Response

200OK

Requesting the account data

curl -X GET 'https://xem.nownodes.io/account/get'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/get')
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://xem.nownodes.io/account/get')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/account/get')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/get')
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)

Requesting the account data (public key)

GET

https://xem.nownodes.io/account/get/from-public-key

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Requesting the account data (public key)

Parameters

publicKeystringquery

Response

200OK

Requesting the account data (public key)

curl -X GET 'https://xem.nownodes.io/account/get/from-public-key'

const response = await fetch('https://xem.nownodes.io/account/get/from-public-key', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/get/from-public-key')
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://xem.nownodes.io/account/get/from-public-key')
data = response.json()

const response = await fetch('https://xem.nownodes.io/account/get/from-public-key', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/account/get/from-public-key";
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://xem.nownodes.io/account/get/from-public-key', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/account/get/from-public-key')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/get/from-public-key')
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)

Requesting the original account data for a delegate account

GET

https://xem.nownodes.io/account/get/forwarded

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Requesting the original account data for a delegate account

Parameters

addressstringquery

Response

200OK

Requesting the original account data for a delegate account

curl -X GET 'https://xem.nownodes.io/account/get/forwarded'

const response = await fetch('https://xem.nownodes.io/account/get/forwarded', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/get/forwarded')
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://xem.nownodes.io/account/get/forwarded')
data = response.json()

const response = await fetch('https://xem.nownodes.io/account/get/forwarded', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/account/get/forwarded";
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://xem.nownodes.io/account/get/forwarded', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/account/get/forwarded')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/get/forwarded')
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)

Requesting the original account data for a delegate account (Public key)

GET

https://xem.nownodes.io/account/get/forwarded/from-public-key

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Requesting the original account data for a delegate account (Public key)

Parameters

publicKeystringquery

Response

200OK

Requesting the original account data for a delegate account (Public key)

curl -X GET 'https://xem.nownodes.io/account/get/forwarded/from-public-key'

const response = await fetch('https://xem.nownodes.io/account/get/forwarded/from-public-key', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/get/forwarded/from-public-key')
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://xem.nownodes.io/account/get/forwarded/from-public-key')
data = response.json()

const response = await fetch('https://xem.nownodes.io/account/get/forwarded/from-public-key', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/account/get/forwarded/from-public-key";
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://xem.nownodes.io/account/get/forwarded/from-public-key', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/account/get/forwarded/from-public-key')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/get/forwarded/from-public-key')
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)

Requesting the account status

GET

https://xem.nownodes.io/account/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Requesting the account status

Parameters

addressstringquery

Response

200OK

Requesting the account status

curl -X GET 'https://xem.nownodes.io/account/status'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

const data = await response.json();

const endpoint = "https://xem.nownodes.io/account/status";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

Requesting transaction data for an account (Incoming)

GET

https://xem.nownodes.io/account/transfers/incoming

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Requesting transaction data for an account (Incoming)

Parameters

addressstringquery

hashstringquery

Response

200OK

Requesting transaction data for an account (Incoming)

curl -X GET 'https://xem.nownodes.io/account/transfers/incoming'

const response = await fetch('https://xem.nownodes.io/account/transfers/incoming', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/transfers/incoming')
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://xem.nownodes.io/account/transfers/incoming')
data = response.json()

const response = await fetch('https://xem.nownodes.io/account/transfers/incoming', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/account/transfers/incoming";
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://xem.nownodes.io/account/transfers/incoming', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/account/transfers/incoming')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/transfers/incoming')
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)

Requesting transaction data for an account (Outgoing)

GET

https://xem.nownodes.io/account/transfers/outgoing

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Requesting transaction data for an account (Outgoing)

Parameters

addressstringquery

hashstringquery

Response

200OK

Requesting transaction data for an account (Outgoing)

curl -X GET 'https://xem.nownodes.io/account/transfers/outgoing'

const response = await fetch('https://xem.nownodes.io/account/transfers/outgoing', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/transfers/outgoing')
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://xem.nownodes.io/account/transfers/outgoing')
data = response.json()

const response = await fetch('https://xem.nownodes.io/account/transfers/outgoing', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/account/transfers/outgoing";
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://xem.nownodes.io/account/transfers/outgoing', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/account/transfers/outgoing')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/transfers/outgoing')
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)

Requesting transaction data for an account (All)

GET

https://xem.nownodes.io/account/transfers/all

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Requesting transaction data for an account (All)

Parameters

addressstringquery

hashstringquery

Response

200OK

Requesting transaction data for an account (All)

curl -X GET 'https://xem.nownodes.io/account/transfers/all'

const response = await fetch('https://xem.nownodes.io/account/transfers/all', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/transfers/all')
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://xem.nownodes.io/account/transfers/all')
data = response.json()

const response = await fetch('https://xem.nownodes.io/account/transfers/all', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/account/transfers/all";
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://xem.nownodes.io/account/transfers/all', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/account/transfers/all')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/transfers/all')
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)

Unconfirmed transactions

GET

https://xem.nownodes.io/account/unconfirmedTransactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Unconfirmed transactions

Parameters

addressstringquery

Response

200OK

Unconfirmed transactions

curl -X GET 'https://xem.nownodes.io/account/unconfirmedTransactions'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/unconfirmedTransactions')
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://xem.nownodes.io/account/unconfirmedTransactions')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/account/unconfirmedTransactions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/unconfirmedTransactions')
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)

Requesting harvest info data for an account

GET

https://xem.nownodes.io/account/harvests

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Requesting harvest info data for an account

Parameters

addressstringquery

hashstringquery

Response

200OK

Requesting harvest info data for an account

curl -X GET 'https://xem.nownodes.io/account/harvests'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/harvests')
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://xem.nownodes.io/account/harvests')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/account/harvests')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/harvests')
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)

Retrieving account importances for accounts

GET

https://xem.nownodes.io/account/importances

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieving account importances for accounts

Response

200OK

Retrieving account importances for accounts

curl -X GET 'https://xem.nownodes.io/account/importances'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/importances')
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://xem.nownodes.io/account/importances')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/account/importances')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/importances')
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)

Retrieving namespaces that an account owns

GET

https://xem.nownodes.io/account/namespace/page

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieving namespaces that an account owns

Parameters

addressstringquery

parentstringquery

Response

200OK

Retrieving namespaces that an account owns

curl -X GET 'https://xem.nownodes.io/account/namespace/page'

const response = await fetch('https://xem.nownodes.io/account/namespace/page', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/namespace/page')
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://xem.nownodes.io/account/namespace/page')
data = response.json()

const response = await fetch('https://xem.nownodes.io/account/namespace/page', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/account/namespace/page";
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://xem.nownodes.io/account/namespace/page', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/account/namespace/page')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/namespace/page')
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)

Retrieving mosaic definitions that an account has created

GET

https://xem.nownodes.io/account/mosaic/definition/page

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieving mosaic definitions that an account has created

Parameters

addressstringquery

parentstringquery

Response

200OK

Retrieving mosaic definitions that an account has created

curl -X GET 'https://xem.nownodes.io/account/mosaic/definition/page'

const response = await fetch('https://xem.nownodes.io/account/mosaic/definition/page', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/mosaic/definition/page')
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://xem.nownodes.io/account/mosaic/definition/page')
data = response.json()

const response = await fetch('https://xem.nownodes.io/account/mosaic/definition/page', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/account/mosaic/definition/page";
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://xem.nownodes.io/account/mosaic/definition/page', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/account/mosaic/definition/page')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/mosaic/definition/page')
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)

Retrieving mosaics that an account owns

GET

https://xem.nownodes.io/account/mosaic/owned

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieving mosaics that an account owns

Parameters

addressstringquery

Response

200OK

Retrieving mosaics that an account owns

curl -X GET 'https://xem.nownodes.io/account/mosaic/owned'

const response = await fetch('https://xem.nownodes.io/account/mosaic/owned', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/mosaic/owned')
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://xem.nownodes.io/account/mosaic/owned')
data = response.json()

const response = await fetch('https://xem.nownodes.io/account/mosaic/owned', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/account/mosaic/owned";
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://xem.nownodes.io/account/mosaic/owned', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/account/mosaic/owned')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/mosaic/owned')
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)

Retrieving historical account data

GET

https://xem.nownodes.io/account/historical/get

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieving historical account data

Parameters

addressstringquery

startHeightstringquery

endHeightstringquery

incrementstringquery

Response

200OK

Retrieving historical account data

curl -X GET 'https://xem.nownodes.io/account/historical/get'

const response = await fetch('https://xem.nownodes.io/account/historical/get', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/historical/get')
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://xem.nownodes.io/account/historical/get')
data = response.json()

const response = await fetch('https://xem.nownodes.io/account/historical/get', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/account/historical/get";
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://xem.nownodes.io/account/historical/get', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/account/historical/get')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/historical/get')
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)

Unlocking the account (enables harvesting)

POST

https://xem.nownodes.io/account/unlock

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Unlocking the account (enables harvesting)

Body

multipart/form-data

privateKeystring

Response

200OK

Unlocking the account (enables harvesting)

curl -X POST 'https://xem.nownodes.io/account/unlock' \
  -H 'Content-Type: multipart/form-data' \
  -d '{
    "privateKey": ""
  }'

const response = await fetch('https://xem.nownodes.io/account/unlock', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "privateKey": ""
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/unlock')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "privateKey": ""
  }'

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

import requests

payload = {
  "privateKey": ""
}

response = requests.post('https://xem.nownodes.io/account/unlock', json=payload)
data = response.json()

const response = await fetch('https://xem.nownodes.io/account/unlock', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "privateKey": ""
    }),
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/account/unlock";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xem.nownodes.io/account/unlock', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "privateKey": ""
    }),
});

const data = await response.json();

import requests

payload = {
  "privateKey": ""
}

response = requests.post('https://xem.nownodes.io/account/unlock', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/unlock')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "privateKey": ""
  }'

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

Request Body

{
  "privateKey": ""
}

Locking the account (stops harvesting)

POST

https://xem.nownodes.io/account/lock

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Locking the account (stops harvesting)

Body

multipart/form-data

privateKeystring

Response

200OK

Locking the account (stops harvesting)

curl -X POST 'https://xem.nownodes.io/account/lock' \
  -H 'Content-Type: multipart/form-data' \
  -d '{
    "privateKey": ""
  }'

const response = await fetch('https://xem.nownodes.io/account/lock', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "privateKey": ""
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/lock')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "privateKey": ""
  }'

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

import requests

payload = {
  "privateKey": ""
}

response = requests.post('https://xem.nownodes.io/account/lock', json=payload)
data = response.json()

const response = await fetch('https://xem.nownodes.io/account/lock', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "privateKey": ""
    }),
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/account/lock";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xem.nownodes.io/account/lock', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "privateKey": ""
    }),
});

const data = await response.json();

import requests

payload = {
  "privateKey": ""
}

response = requests.post('https://xem.nownodes.io/account/lock', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/lock')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "privateKey": ""
  }'

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

Request Body

{
  "privateKey": ""
}

Retrieving the unlock info

POST

https://xem.nownodes.io/account/unlocked/info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieving the unlock info

Response

200OK

Retrieving the unlock info

curl -X POST 'https://xem.nownodes.io/account/unlocked/info'

const response = await fetch('https://xem.nownodes.io/account/unlocked/info', {
  method: 'POST',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/unlocked/info')
request = Net::HTTP::Post.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.post('https://xem.nownodes.io/account/unlocked/info')
data = response.json()

const response = await fetch('https://xem.nownodes.io/account/unlocked/info', {
  method: 'POST',
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/account/unlocked/info";
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({});
console.log(result);

const response = await fetch('https://xem.nownodes.io/account/unlocked/info', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://xem.nownodes.io/account/unlocked/info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/account/unlocked/info')
request = Net::HTTP::Post.new(uri)

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

Chain

Block chain height

GET

https://xem.nownodes.io/chain/height

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Block chain height

Response

200OK

Block chain height

curl -X GET 'https://xem.nownodes.io/chain/height'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/chain/height')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xem.nownodes.io/chain/height')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xem.nownodes.io/chain/height";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/chain/height')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/chain/height')
request = Net::HTTP::Get.new(uri)

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

Block chain score

GET

https://xem.nownodes.io/chain/score

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Block chain score

Response

200OK

Block chain score

curl -X GET 'https://xem.nownodes.io/chain/score'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/chain/score')
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://xem.nownodes.io/chain/score')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/chain/score')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/chain/score')
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)

Last block of the block chain score

GET

https://xem.nownodes.io/chain/last-block

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Last block of the block chain score

Response

200OK

Last block of the block chain score

curl -X GET 'https://xem.nownodes.io/chain/last-block'

const response = await fetch('https://xem.nownodes.io/chain/last-block', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/chain/last-block')
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://xem.nownodes.io/chain/last-block')
data = response.json()

const response = await fetch('https://xem.nownodes.io/chain/last-block', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/chain/last-block";
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://xem.nownodes.io/chain/last-block', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/chain/last-block')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/chain/last-block')
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)

Block

Getting a block with a given hash

GET

https://xem.nownodes.io/block/get

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Getting a block with a given hash

Parameters

blockHashstringquery

Response

200OK

Getting a block with a given hash

curl -X GET 'https://xem.nownodes.io/block/get'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/block/get')
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://xem.nownodes.io/block/get')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/block/get')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/block/get')
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)

Getting a block with a given height

POST

https://xem.nownodes.io/block/at/public

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Getting a block with a given height

Body

multipart/form-data

blockHeight string

Response

200OK

Getting a block with a given height

curl -X POST 'https://xem.nownodes.io/block/at/public' \
  -H 'Content-Type: multipart/form-data' \
  -d '{
    "blockHeight ": ""
  }'

const response = await fetch('https://xem.nownodes.io/block/at/public', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "blockHeight ": ""
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/block/at/public')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "blockHeight ": ""
  }'

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

import requests

payload = {
  "blockHeight ": ""
}

response = requests.post('https://xem.nownodes.io/block/at/public', json=payload)
data = response.json()

const response = await fetch('https://xem.nownodes.io/block/at/public', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "blockHeight ": ""
    }),
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/block/at/public";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xem.nownodes.io/block/at/public', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "blockHeight ": ""
    }),
});

const data = await response.json();

import requests

payload = {
  "blockHeight ": ""
}

response = requests.post('https://xem.nownodes.io/block/at/public', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/block/at/public')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "blockHeight ": ""
  }'

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

Request Body

{
  "blockHeight ": ""
}

Node

Extended node information

GET

https://xem.nownodes.io/node/extended-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Extended node information

Response

200OK

Extended node information

curl -X GET 'https://xem.nownodes.io/node/extended-info'

const response = await fetch('https://xem.nownodes.io/node/extended-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/node/extended-info')
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://xem.nownodes.io/node/extended-info')
data = response.json()

const response = await fetch('https://xem.nownodes.io/node/extended-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/node/extended-info";
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://xem.nownodes.io/node/extended-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/node/extended-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/node/extended-info')
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)

Complete neighborhood

GET

https://xem.nownodes.io/node/peer-list/all

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Complete neighborhood

Response

200OK

Complete neighborhood

curl -X GET 'https://xem.nownodes.io/node/peer-list/all'

const response = await fetch('https://xem.nownodes.io/node/peer-list/all', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/node/peer-list/all')
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://xem.nownodes.io/node/peer-list/all')
data = response.json()

const response = await fetch('https://xem.nownodes.io/node/peer-list/all', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/node/peer-list/all";
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://xem.nownodes.io/node/peer-list/all', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/node/peer-list/all')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/node/peer-list/all')
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)

Reachable neighborhood

GET

https://xem.nownodes.io/node/peer-list/reachable

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Reachable neighborhood

Response

200OK

Reachable neighborhood

curl -X GET 'https://xem.nownodes.io/node/peer-list/reachable'

const response = await fetch('https://xem.nownodes.io/node/peer-list/reachable', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/node/peer-list/reachable')
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://xem.nownodes.io/node/peer-list/reachable')
data = response.json()

const response = await fetch('https://xem.nownodes.io/node/peer-list/reachable', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/node/peer-list/reachable";
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://xem.nownodes.io/node/peer-list/reachable', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/node/peer-list/reachable')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/node/peer-list/reachable')
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)

Active neighborhood

GET

https://xem.nownodes.io/node/peer-list/active

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Active neighborhood

Response

200OK

Active neighborhood

curl -X GET 'https://xem.nownodes.io/node/peer-list/active'

const response = await fetch('https://xem.nownodes.io/node/peer-list/active', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/node/peer-list/active')
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://xem.nownodes.io/node/peer-list/active')
data = response.json()

const response = await fetch('https://xem.nownodes.io/node/peer-list/active', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/node/peer-list/active";
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://xem.nownodes.io/node/peer-list/active', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/node/peer-list/active')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/node/peer-list/active')
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)

Maximum chain height in the active neighborhood

GET

https://xem.nownodes.io/node/active-peers/max-chain-height

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Maximum chain height in the active neighborhood

Response

200OK

Maximum chain height in the active neighborhood

curl -X GET 'https://xem.nownodes.io/node/active-peers/max-chain-height'

const response = await fetch('https://xem.nownodes.io/node/active-peers/max-chain-height', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/node/active-peers/max-chain-height')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xem.nownodes.io/node/active-peers/max-chain-height')
data = response.json()

const response = await fetch('https://xem.nownodes.io/node/active-peers/max-chain-height', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/node/active-peers/max-chain-height";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xem.nownodes.io/node/active-peers/max-chain-height', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/node/active-peers/max-chain-height')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/node/active-peers/max-chain-height')
request = Net::HTTP::Get.new(uri)

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

Requesting node experiences

GET

https://xem.nownodes.io/node/experiences

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Requesting node experiences

Response

200OK

Requesting node experiences

curl -X GET 'https://xem.nownodes.io/node/experiences'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/node/experiences')
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://xem.nownodes.io/node/experiences')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/node/experiences')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/node/experiences')
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)

Booting the local node

POST

https://xem.nownodes.io/node/boot

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Booting the local node

Body

multipart/form-data

bootNodeRequeststring

Response

200OK

Booting the local node

curl -X POST 'https://xem.nownodes.io/node/boot' \
  -H 'Content-Type: multipart/form-data' \
  -d '{
    "bootNodeRequest": ""
  }'

const response = await fetch('https://xem.nownodes.io/node/boot', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "bootNodeRequest": ""
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/node/boot')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "bootNodeRequest": ""
  }'

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

import requests

payload = {
  "bootNodeRequest": ""
}

response = requests.post('https://xem.nownodes.io/node/boot', json=payload)
data = response.json()

const response = await fetch('https://xem.nownodes.io/node/boot', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "bootNodeRequest": ""
    }),
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/node/boot";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xem.nownodes.io/node/boot', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "bootNodeRequest": ""
    }),
});

const data = await response.json();

import requests

payload = {
  "bootNodeRequest": ""
}

response = requests.post('https://xem.nownodes.io/node/boot', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/node/boot')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "bootNodeRequest": ""
  }'

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

Request Body

{
  "bootNodeRequest": ""
}

Namespace

Retrieving root namespaces

GET

https://xem.nownodes.io/namespace/roots

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieving root namespaces

Parameters

idstringquery

pageSize;stringquery

Response

200OK

Retrieving root namespaces

curl -X GET 'https://xem.nownodes.io/namespace/roots'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/namespace/roots')
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://xem.nownodes.io/namespace/roots')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/namespace/roots')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/namespace/roots')
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)

Retrieving a specific namespace

GET

https://xem.nownodes.io/namespace

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieving a specific namespace

Parameters

namespacestringquery

Response

200OK

Retrieving a specific namespace

curl -X GET 'https://xem.nownodes.io/namespace'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/namespace')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/namespace')
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)

Retrieving mosaic definitions

GET

https://xem.nownodes.io/namespace/mosaic/definition/page

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieving mosaic definitions

Parameters

namespacestringquery

Response

200OK

Retrieving mosaic definitions

curl -X GET 'https://xem.nownodes.io/namespace/mosaic/definition/page'

const response = await fetch('https://xem.nownodes.io/namespace/mosaic/definition/page', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/namespace/mosaic/definition/page')
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://xem.nownodes.io/namespace/mosaic/definition/page')
data = response.json()

const response = await fetch('https://xem.nownodes.io/namespace/mosaic/definition/page', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/namespace/mosaic/definition/page";
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://xem.nownodes.io/namespace/mosaic/definition/page', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/namespace/mosaic/definition/page')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/namespace/mosaic/definition/page')
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)

Debug

Monitoring the network time

GET

https://xem.nownodes.io/debug/time-synchronization

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Monitoring the network time

Response

200OK

Monitoring the network time

curl -X GET 'https://xem.nownodes.io/debug/time-synchronization'

const response = await fetch('https://xem.nownodes.io/debug/time-synchronization', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/debug/time-synchronization')
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://xem.nownodes.io/debug/time-synchronization')
data = response.json()

const response = await fetch('https://xem.nownodes.io/debug/time-synchronization', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/debug/time-synchronization";
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://xem.nownodes.io/debug/time-synchronization', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/debug/time-synchronization')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/debug/time-synchronization')
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)

Monitoring incoming calls

GET

https://xem.nownodes.io/debug/connections/incoming

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Monitoring incoming calls

Response

200OK

Monitoring incoming calls

curl -X GET 'https://xem.nownodes.io/debug/connections/incoming'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/debug/connections/incoming')
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://xem.nownodes.io/debug/connections/incoming')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xem.nownodes.io/debug/connections/incoming";
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://xem.nownodes.io/debug/connections/incoming', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/debug/connections/incoming')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/debug/connections/incoming')
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)

Monitoring outgoing calls

GET

https://xem.nownodes.io/debug/connections/outgoing

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Monitoring outgoing calls

Response

200OK

Monitoring outgoing calls

curl -X GET 'https://xem.nownodes.io/debug/connections/outgoing'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/debug/connections/outgoing')
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://xem.nownodes.io/debug/connections/outgoing')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xem.nownodes.io/debug/connections/outgoing";
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://xem.nownodes.io/debug/connections/outgoing', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/debug/connections/outgoing')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/debug/connections/outgoing')
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)

Monitoring timers

GET

https://xem.nownodes.io/debug/timers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Monitoring timers

Response

200OK

Monitoring timers

curl -X GET 'https://xem.nownodes.io/debug/timers'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/debug/timers')
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://xem.nownodes.io/debug/timers')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xem.nownodes.io/debug/timers')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/debug/timers')
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)

Local

Incoming transactions with decoded messages

POST

https://xem.nownodes.io/local/account/transfers/incoming

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Incoming transactions with decoded messages

Body

multipart/form-data

pagestring

Response

200OK

Incoming transactions with decoded messages

curl -X POST 'https://xem.nownodes.io/local/account/transfers/incoming' \
  -H 'Content-Type: multipart/form-data' \
  -d '{
    "page": ""
  }'

const response = await fetch('https://xem.nownodes.io/local/account/transfers/incoming', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "page": ""
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/local/account/transfers/incoming')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "page": ""
  }'

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

import requests

payload = {
  "page": ""
}

response = requests.post('https://xem.nownodes.io/local/account/transfers/incoming', json=payload)
data = response.json()

const response = await fetch('https://xem.nownodes.io/local/account/transfers/incoming', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "page": ""
    }),
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/local/account/transfers/incoming";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xem.nownodes.io/local/account/transfers/incoming', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "page": ""
    }),
});

const data = await response.json();

import requests

payload = {
  "page": ""
}

response = requests.post('https://xem.nownodes.io/local/account/transfers/incoming', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/local/account/transfers/incoming')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "page": ""
  }'

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

Request Body

{
  "page": ""
}

Outgoing transactions with decoded messages

POST

https://xem.nownodes.io/local/account/transfers/outgoing

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Outgoing transactions with decoded messages

Body

multipart/form-data

pagestring

Response

200OK

Outgoing transactions with decoded messages

curl -X POST 'https://xem.nownodes.io/local/account/transfers/outgoing' \
  -H 'Content-Type: multipart/form-data' \
  -d '{
    "page": ""
  }'

const response = await fetch('https://xem.nownodes.io/local/account/transfers/outgoing', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "page": ""
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/local/account/transfers/outgoing')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "page": ""
  }'

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

import requests

payload = {
  "page": ""
}

response = requests.post('https://xem.nownodes.io/local/account/transfers/outgoing', json=payload)
data = response.json()

const response = await fetch('https://xem.nownodes.io/local/account/transfers/outgoing', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "page": ""
    }),
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/local/account/transfers/outgoing";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xem.nownodes.io/local/account/transfers/outgoing', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "page": ""
    }),
});

const data = await response.json();

import requests

payload = {
  "page": ""
}

response = requests.post('https://xem.nownodes.io/local/account/transfers/outgoing', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/local/account/transfers/outgoing')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "page": ""
  }'

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

Request Body

{
  "page": ""
}

All transactions with decoded messages

POST

https://xem.nownodes.io/local/account/transfers/all

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

All transactions with decoded messages

Body

multipart/form-data

pagestring

Response

200OK

All transactions with decoded messages

curl -X POST 'https://xem.nownodes.io/local/account/transfers/all' \
  -H 'Content-Type: multipart/form-data' \
  -d '{
    "page": ""
  }'

const response = await fetch('https://xem.nownodes.io/local/account/transfers/all', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "page": ""
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/local/account/transfers/all')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "page": ""
  }'

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

import requests

payload = {
  "page": ""
}

response = requests.post('https://xem.nownodes.io/local/account/transfers/all', json=payload)
data = response.json()

const response = await fetch('https://xem.nownodes.io/local/account/transfers/all', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "page": ""
    }),
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/local/account/transfers/all";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xem.nownodes.io/local/account/transfers/all', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "page": ""
    }),
});

const data = await response.json();

import requests

payload = {
  "page": ""
}

response = requests.post('https://xem.nownodes.io/local/account/transfers/all', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/local/account/transfers/all')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "page": ""
  }'

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

Request Body

{
  "page": ""
}

Getting part of a chain

POST

https://xem.nownodes.io/local/chain/blocks-after

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Getting part of a chain

Body

multipart/form-data

blockHeightstring

Response

200OK

Getting part of a chain

curl -X POST 'https://xem.nownodes.io/local/chain/blocks-after' \
  -H 'Content-Type: multipart/form-data' \
  -d '{
    "blockHeight": ""
  }'

const response = await fetch('https://xem.nownodes.io/local/chain/blocks-after', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "blockHeight": ""
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/local/chain/blocks-after')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "blockHeight": ""
  }'

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

import requests

payload = {
  "blockHeight": ""
}

response = requests.post('https://xem.nownodes.io/local/chain/blocks-after', json=payload)
data = response.json()

const response = await fetch('https://xem.nownodes.io/local/chain/blocks-after', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "blockHeight": ""
    }),
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/local/chain/blocks-after";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xem.nownodes.io/local/chain/blocks-after', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "blockHeight": ""
    }),
});

const data = await response.json();

import requests

payload = {
  "blockHeight": ""
}

response = requests.post('https://xem.nownodes.io/local/chain/blocks-after', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/local/chain/blocks-after')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "blockHeight": ""
  }'

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

Request Body

{
  "blockHeight": ""
}

Transaction

Initiating a transaction

POST

https://xem.nownodes.io/transaction/prepare-announce

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Initiating a transaction

Body

multipart/form-data

requestPrepareAnnouncestring

Response

200OK

Initiating a transaction

curl -X POST 'https://xem.nownodes.io/transaction/prepare-announce' \
  -H 'Content-Type: multipart/form-data' \
  -d '{
    "requestPrepareAnnounce": ""
  }'

const response = await fetch('https://xem.nownodes.io/transaction/prepare-announce', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "requestPrepareAnnounce": ""
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/transaction/prepare-announce')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "requestPrepareAnnounce": ""
  }'

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

import requests

payload = {
  "requestPrepareAnnounce": ""
}

response = requests.post('https://xem.nownodes.io/transaction/prepare-announce', json=payload)
data = response.json()

const response = await fetch('https://xem.nownodes.io/transaction/prepare-announce', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "requestPrepareAnnounce": ""
    }),
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/transaction/prepare-announce";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xem.nownodes.io/transaction/prepare-announce', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "requestPrepareAnnounce": ""
    }),
});

const data = await response.json();

import requests

payload = {
  "requestPrepareAnnounce": ""
}

response = requests.post('https://xem.nownodes.io/transaction/prepare-announce', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/transaction/prepare-announce')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "requestPrepareAnnounce": ""
  }'

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

Request Body

{
  "requestPrepareAnnounce": ""
}

Sending the data to NIS

POST

https://xem.nownodes.io/transaction/announce

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Sending the data to NIS

Body

multipart/form-data

requestAnnouncestring

Response

200OK

Sending the data to NIS

curl -X POST 'https://xem.nownodes.io/transaction/announce' \
  -H 'Content-Type: multipart/form-data' \
  -d '{
    "requestAnnounce": ""
  }'

const response = await fetch('https://xem.nownodes.io/transaction/announce', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "requestAnnounce": ""
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/transaction/announce')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "requestAnnounce": ""
  }'

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

import requests

payload = {
  "requestAnnounce": ""
}

response = requests.post('https://xem.nownodes.io/transaction/announce', json=payload)
data = response.json()

const response = await fetch('https://xem.nownodes.io/transaction/announce', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "requestAnnounce": ""
    }),
});

const data = await response.json();

const endpoint = "https://xem.nownodes.io/transaction/announce";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xem.nownodes.io/transaction/announce', {
  method: 'POST',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  body: JSON.stringify({
      "requestAnnounce": ""
    }),
});

const data = await response.json();

import requests

payload = {
  "requestAnnounce": ""
}

response = requests.post('https://xem.nownodes.io/transaction/announce', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xem.nownodes.io/transaction/announce')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'multipart/form-data'
request.body = '{
    "requestAnnounce": ""
  }'

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

Request Body

{
  "requestAnnounce": ""
}

Documentation

How to migrate to NOWNodes

Authentication

Node

Heartbeat

Authorizations

Response

Status

Authorizations

Response

Account

Authorizations

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Response

Chain

Authorizations

Response

Authorizations

Response

Authorizations

Response

Block

Authorizations

Parameters

Response

Authorizations

Body

Response

Node