MultiversX Gateway API

v1.1.0

Base URL

https://egld.nownodes.io

API for interacting with the MultiversX blockchain network

Authentication

apiKeyapiKey

API key for authentication

API Key: api-key in header

REST-API

about

GET

https://egld.nownodes.io/about

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the proxy's version and commit hash

Response

200OK

Successful operation

GET /about

curl -X GET 'https://egld.nownodes.io/about'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://egld.nownodes.io/about')
data = response.json()

require 'net/http'
require 'json'

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

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

200

{
  "data": {
    "version": "v1.1.0",
    "commitHash": "a1b2c3d4e5f67890"
  },
  "error": "",
  "code": "successful"
}

GET

https://egld.nownodes.io/about/nodes-versions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the app versions of the nodes behind the proxy

Response

200OK

Successful operation

GET /about/nodes-versions

curl -X GET 'https://egld.nownodes.io/about/nodes-versions'

const response = await fetch('https://egld.nownodes.io/about/nodes-versions', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/about/nodes-versions')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://egld.nownodes.io/about/nodes-versions')
data = response.json()

const response = await fetch('https://egld.nownodes.io/about/nodes-versions', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://egld.nownodes.io/about/nodes-versions";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://egld.nownodes.io/about/nodes-versions', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://egld.nownodes.io/about/nodes-versions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/about/nodes-versions')
request = Net::HTTP::Get.new(uri)

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

200

{
  "data": {
    "observer-1-shard-0": "v1.5.0",
    "observer-2-shard-1": "v1.5.0",
    "observer-3-shard-2": "v1.5.0"
  },
  "error": "",
  "code": "successful"
}

address

GET

https://egld.nownodes.io/address/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns data about an address

Parameters

addressstringrequiredpath

The address in bech32 format

Response

200OK

Successful operation

GET /address/{address}

curl -X GET 'https://egld.nownodes.io/address/{address}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/address/{address}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://egld.nownodes.io/address/{address}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://egld.nownodes.io/address/{address}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://egld.nownodes.io/address/{address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/address/{address}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "data": {
    "address": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
    "nonce": 42,
    "balance": "1000000000000000000000",
    "username": "alice.elrond",
    "code": "",
    "codeHash": [],
    "rootHash": [
      104,
      101,
      120,
      104,
      97,
      115,
      104
    ]
  },
  "error": "",
  "code": "successful"
}

GET

https://egld.nownodes.io/address/{address}/balance

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the balance of the provided address in string format

Parameters

addressstringrequiredpath

The address in bech32 format

Response

200OK

Successful operation

GET /address/{address}/balance

curl -X GET 'https://egld.nownodes.io/address/{address}/balance'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://egld.nownodes.io/address/{address}/balance')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/address/{address}/balance')
request = Net::HTTP::Get.new(uri)

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

200

{
  "data": {
    "balance": "1000000000000000000000"
  },
  "error": "",
  "code": "successful"
}

GET

https://egld.nownodes.io/address/{address}/nonce

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the nonce of the provided address

Parameters

addressstringrequiredpath

The address in bech32 format

Response

200OK

Successful operation

GET /address/{address}/nonce

curl -X GET 'https://egld.nownodes.io/address/{address}/nonce'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://egld.nownodes.io/address/{address}/nonce')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/address/{address}/nonce')
request = Net::HTTP::Get.new(uri)

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

200

{
  "data": {
    "nonce": 42
  },
  "error": "",
  "code": "successful"
}

GET

https://egld.nownodes.io/address/{address}/username

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the username of the provided address

Parameters

addressstringrequiredpath

The address in bech32 format

Response

200OK

Successful operation

GET /address/{address}/username

curl -X GET 'https://egld.nownodes.io/address/{address}/username'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://egld.nownodes.io/address/{address}/username')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/address/{address}/username')
request = Net::HTTP::Get.new(uri)

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

200

{
  "data": {
    "username": "alice.elrond"
  },
  "error": "",
  "code": "successful"
}

GET

https://egld.nownodes.io/address/{address}/shard

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the shard ID of the provided address

Parameters

addressstringrequiredpath

The address in bech32 format

Response

200OK

Successful operation

GET /address/{address}/shard

curl -X GET 'https://egld.nownodes.io/address/{address}/shard'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://egld.nownodes.io/address/{address}/shard')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/address/{address}/shard')
request = Net::HTTP::Get.new(uri)

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

200

{
  "data": {
    "shardID": 1
  },
  "error": "",
  "code": "successful"
}

GET

https://egld.nownodes.io/address/{address}/key/{key}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the value of the provided key for an address

Parameters

addressstringrequiredpath

The address in bech32 format

keystringrequiredpath

Storage key to retrieve

Response

200OK

Successful operation

GET /address/{address}/key/{key}

curl -X GET 'https://egld.nownodes.io/address/{address}/key/{key}'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://egld.nownodes.io/address/{address}/key/{key}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/address/{address}/key/{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)

200

{
  "data": {
    "value": "000000000000000000000000000000000000000000000000000000000000002a"
  },
  "error": "",
  "code": "successful"
}

GET

https://egld.nownodes.io/address/{address}/esdt

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all ESDT tokens that the provided address interacted with

Parameters

addressstringrequiredpath

The address in bech32 format

Response

200OK

Successful operation

GET /address/{address}/esdt

curl -X GET 'https://egld.nownodes.io/address/{address}/esdt'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://egld.nownodes.io/address/{address}/esdt')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/address/{address}/esdt')
request = Net::HTTP::Get.new(uri)

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

200

{
  "data": {
    "tokens": [
      "MYTOKEN-123456",
      "WEGLD-abcdef"
    ]
  },
  "error": "",
  "code": "successful"
}

GET

https://egld.nownodes.io/address/{address}/esdt/{tokenIdentifier}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns ESDT token data for the provided address and token identifier

Parameters

addressstringrequiredpath

The address in bech32 format

tokenIdentifierstringrequiredpath

The token identifier to search for

Response

200OK

Successful operation

GET /address/{address}/esdt/{tokenIdentifier}

curl -X GET 'https://egld.nownodes.io/address/{address}/esdt/{tokenIdentifier}'

const response = await fetch('https://egld.nownodes.io/address/{address}/esdt/{tokenIdentifier}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/address/{address}/esdt/{tokenIdentifier}')
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://egld.nownodes.io/address/{address}/esdt/{tokenIdentifier}')
data = response.json()

const response = await fetch('https://egld.nownodes.io/address/{address}/esdt/{tokenIdentifier}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://egld.nownodes.io/address/{address}/esdt/{tokenIdentifier}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/address/{address}/esdt/{tokenIdentifier}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "data": {
    "tokenIdentifier": "WEGLD-abcdef",
    "balance": "5000000000000000000",
    "properties": "canFreeze: true, canWipe: true, canPause: true"
  },
  "error": "",
  "code": "successful"
}

network

GET

https://egld.nownodes.io/network/config

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the configuration of the network

Response

200OK

Successful operation

GET /network/config

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

200

{
  "data": {
    "chainID": "1",
    "minGasLimit": 50000,
    "minGasPrice": 1000000000,
    "maxGasPrice": 1000000000000
  },
  "error": "",
  "code": "successful"
}

GET

https://egld.nownodes.io/network/economics

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the economics data metric from the last epoch

Response

200OK

Successful operation

GET /network/economics

curl -X GET 'https://egld.nownodes.io/network/economics'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

200

{
  "data": {
    "totalSupply": "3141592653589793238",
    "circulatingSupply": "2718281828459045235",
    "staked": "1414213562373095048",
    "price": "50000000000000000000"
  },
  "error": "",
  "code": "successful"
}

transaction

POST

https://egld.nownodes.io/transaction/send

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Sends a transaction to the network

Body

application/json

nonceintegerrequired

Transaction nonce

valuestringrequired

Transaction value in wei

receiverstringrequired

Receiver address in bech32 format

senderstringrequired

Sender address in bech32 format

gasPriceintegerrequired

Gas price

gasLimitintegerrequired

Gas limit

datastring

Transaction data (base64 encoded)

chainIDstringrequired

Network chain identifier

versionintegerrequired

Transaction version

signaturestringrequired

Transaction signature

Response

200OK

Successful operation

400Bad Request

Validation error

POST /transaction/send

curl -X POST 'https://egld.nownodes.io/transaction/send' \
  -H 'Content-Type: application/json' \
  -d '{
    "nonce": 42,
    "value": "1000000000000000000",
    "receiver": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
    "sender": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
    "gasPrice": 1000000000,
    "gasLimit": 50000,
    "data": "dGVzdA==",
    "chainID": "1",
    "version": 1,
    "signature": "5f9f8ede6c993944095ffa9c4356ccbbafc0a2d98df2fff93ad9e000366e42af332a8c907d93fe43f22f5b4763b408152bb3fb6a454c73473c86a509f011ba0f"
  }'

const response = await fetch('https://egld.nownodes.io/transaction/send', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "nonce": 42,
      "value": "1000000000000000000",
      "receiver": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
      "sender": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
      "gasPrice": 1000000000,
      "gasLimit": 50000,
      "data": "dGVzdA==",
      "chainID": "1",
      "version": 1,
      "signature": "5f9f8ede6c993944095ffa9c4356ccbbafc0a2d98df2fff93ad9e000366e42af332a8c907d93fe43f22f5b4763b408152bb3fb6a454c73473c86a509f011ba0f"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/transaction/send')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "nonce": 42,
    "value": "1000000000000000000",
    "receiver": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
    "sender": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
    "gasPrice": 1000000000,
    "gasLimit": 50000,
    "data": "dGVzdA==",
    "chainID": "1",
    "version": 1,
    "signature": "5f9f8ede6c993944095ffa9c4356ccbbafc0a2d98df2fff93ad9e000366e42af332a8c907d93fe43f22f5b4763b408152bb3fb6a454c73473c86a509f011ba0f"
  }'

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

import requests

payload = {
  "nonce": 42,
  "value": "1000000000000000000",
  "receiver": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
  "sender": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
  "gasPrice": 1000000000,
  "gasLimit": 50000,
  "data": "dGVzdA==",
  "chainID": "1",
  "version": 1,
  "signature": "5f9f8ede6c993944095ffa9c4356ccbbafc0a2d98df2fff93ad9e000366e42af332a8c907d93fe43f22f5b4763b408152bb3fb6a454c73473c86a509f011ba0f"
}

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

const response = await fetch('https://egld.nownodes.io/transaction/send', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "nonce": 42,
      "value": "1000000000000000000",
      "receiver": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
      "sender": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
      "gasPrice": 1000000000,
      "gasLimit": 50000,
      "data": "dGVzdA==",
      "chainID": "1",
      "version": 1,
      "signature": "5f9f8ede6c993944095ffa9c4356ccbbafc0a2d98df2fff93ad9e000366e42af332a8c907d93fe43f22f5b4763b408152bb3fb6a454c73473c86a509f011ba0f"
    }),
});

const data = await response.json();

const endpoint = "https://egld.nownodes.io/transaction/send";
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({
    "nonce": 42,
    "value": "1000000000000000000",
    "receiver": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
    "sender": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
    "gasPrice": 1000000000,
    "gasLimit": 50000,
    "data": "dGVzdA==",
    "chainID": "1",
    "version": 1,
    "signature": "5f9f8ede6c993944095ffa9c4356ccbbafc0a2d98df2fff93ad9e000366e42af332a8c907d93fe43f22f5b4763b408152bb3fb6a454c73473c86a509f011ba0f"
  });
console.log(result);

const response = await fetch('https://egld.nownodes.io/transaction/send', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "nonce": 42,
      "value": "1000000000000000000",
      "receiver": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
      "sender": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
      "gasPrice": 1000000000,
      "gasLimit": 50000,
      "data": "dGVzdA==",
      "chainID": "1",
      "version": 1,
      "signature": "5f9f8ede6c993944095ffa9c4356ccbbafc0a2d98df2fff93ad9e000366e42af332a8c907d93fe43f22f5b4763b408152bb3fb6a454c73473c86a509f011ba0f"
    }),
});

const data = await response.json();

import requests

payload = {
  "nonce": 42,
  "value": "1000000000000000000",
  "receiver": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
  "sender": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
  "gasPrice": 1000000000,
  "gasLimit": 50000,
  "data": "dGVzdA==",
  "chainID": "1",
  "version": 1,
  "signature": "5f9f8ede6c993944095ffa9c4356ccbbafc0a2d98df2fff93ad9e000366e42af332a8c907d93fe43f22f5b4763b408152bb3fb6a454c73473c86a509f011ba0f"
}

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

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/transaction/send')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "nonce": 42,
    "value": "1000000000000000000",
    "receiver": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
    "sender": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
    "gasPrice": 1000000000,
    "gasLimit": 50000,
    "data": "dGVzdA==",
    "chainID": "1",
    "version": 1,
    "signature": "5f9f8ede6c993944095ffa9c4356ccbbafc0a2d98df2fff93ad9e000366e42af332a8c907d93fe43f22f5b4763b408152bb3fb6a454c73473c86a509f011ba0f"
  }'

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

Request Body

{
  "nonce": 42,
  "value": "1000000000000000000",
  "receiver": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
  "sender": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
  "gasPrice": 1000000000,
  "gasLimit": 50000,
  "data": "dGVzdA==",
  "chainID": "1",
  "version": 1,
  "signature": "5f9f8ede6c993944095ffa9c4356ccbbafc0a2d98df2fff93ad9e000366e42af332a8c907d93fe43f22f5b4763b408152bb3fb6a454c73473c86a509f011ba0f"
}

200

{
  "data": {
    "txHash": "a1b2c3d4e5f6789012345678901234567890123456789012345678901234567890"
  },
  "error": "",
  "code": "successful"
}

GET

https://egld.nownodes.io/transaction/{txhash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the transaction which corresponds to the hash

Parameters

txhashstringrequiredpath

The transaction hash to search for

Response

200OK

Successful operation

GET /transaction/{txhash}

curl -X GET 'https://egld.nownodes.io/transaction/{txhash}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/transaction/{txhash}')
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://egld.nownodes.io/transaction/{txhash}')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://egld.nownodes.io/transaction/{txhash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/transaction/{txhash}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "data": {
    "hash": "a1b2c3d4e5f6789012345678901234567890123456789012345678901234567890",
    "nonce": 42,
    "sender": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
    "receiver": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
    "value": "1000000000000000000",
    "gasLimit": 50000,
    "gasPrice": 1000000000,
    "data": "dGVzdA==",
    "status": "executed"
  },
  "error": "",
  "code": "successful"
}

GET

https://egld.nownodes.io/transaction/{txhash}/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the status of the transaction which corresponds to the hash

Parameters

txhashstringrequiredpath

The transaction hash to search for

Response

200OK

Successful operation

GET /transaction/{txhash}/status

curl -X GET 'https://egld.nownodes.io/transaction/{txhash}/status'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/transaction/{txhash}/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://egld.nownodes.io/transaction/{txhash}/status')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://egld.nownodes.io/transaction/{txhash}/status')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/transaction/{txhash}/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)

200

{
  "data": {
    "status": "executed"
  },
  "error": "",
  "code": "successful"
}

block

GET

https://egld.nownodes.io/block/{shard}/by-nonce/{nonce}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a block by nonce and shard

Parameters

shardintegerrequiredpath

The shard ID to look after

nonceintegerrequiredpath

The block nonce to look after

Response

200OK

Successful operation

GET /block/{shard}/by-nonce/{nonce}

curl -X GET 'https://egld.nownodes.io/block/{shard}/by-nonce/{nonce}'

const response = await fetch('https://egld.nownodes.io/block/{shard}/by-nonce/{nonce}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/block/{shard}/by-nonce/{nonce}')
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://egld.nownodes.io/block/{shard}/by-nonce/{nonce}')
data = response.json()

const response = await fetch('https://egld.nownodes.io/block/{shard}/by-nonce/{nonce}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://egld.nownodes.io/block/{shard}/by-nonce/{nonce}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/block/{shard}/by-nonce/{nonce}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "data": {
    "hash": "b2c3d4e5f6789012345678901234567890123456789012345678901234567890a1",
    "nonce": 1234567,
    "epoch": 500,
    "shard": 1,
    "round": 9876543,
    "timestamp": 1634567890,
    "proposer": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
    "txCount": 150
  },
  "error": "",
  "code": "successful"
}

hyperblock

GET

https://egld.nownodes.io/hyperblock/by-nonce/{nonce}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Gets the hyperblock at the specified nonce

Parameters

nonceintegerrequiredpath

The nonce to look after

Response

200OK

Successful operation

GET /hyperblock/by-nonce/{nonce}

curl -X GET 'https://egld.nownodes.io/hyperblock/by-nonce/{nonce}'

const response = await fetch('https://egld.nownodes.io/hyperblock/by-nonce/{nonce}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/hyperblock/by-nonce/{nonce}')
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://egld.nownodes.io/hyperblock/by-nonce/{nonce}')
data = response.json()

const response = await fetch('https://egld.nownodes.io/hyperblock/by-nonce/{nonce}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://egld.nownodes.io/hyperblock/by-nonce/{nonce}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/hyperblock/by-nonce/{nonce}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "data": {
    "hash": "c3d4e5f6789012345678901234567890123456789012345678901234567890a1b2",
    "nonce": 1234567,
    "epoch": 500,
    "timestamp": 1634567890,
    "transactions": []
  },
  "error": "",
  "code": "successful"
}

vm-values

POST

https://egld.nownodes.io/vm-values/query

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Sends a request to the virtual machines and retrieves the result including altered accounts

Body

application/json

scAddressstring

Smart contract address

funcNamestring

Function name to call

callerAddrstring

Caller address

callValuestring

Value to send with the call

argsArray<string>

Function arguments

Response

200OK

Successful operation

POST /vm-values/query

curl -X POST 'https://egld.nownodes.io/vm-values/query' \
  -H 'Content-Type: application/json' \
  -d '{
    "scAddress": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
    "funcName": "getAllESDTTokens",
    "callerAddr": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
    "callValue": "0",
    "args": []
  }'

const response = await fetch('https://egld.nownodes.io/vm-values/query', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "scAddress": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
      "funcName": "getAllESDTTokens",
      "callerAddr": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
      "callValue": "0",
      "args": []
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/vm-values/query')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "scAddress": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
    "funcName": "getAllESDTTokens",
    "callerAddr": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
    "callValue": "0",
    "args": []
  }'

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

import requests

payload = {
  "scAddress": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
  "funcName": "getAllESDTTokens",
  "callerAddr": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
  "callValue": "0",
  "args": []
}

response = requests.post('https://egld.nownodes.io/vm-values/query', json=payload)
data = response.json()

const response = await fetch('https://egld.nownodes.io/vm-values/query', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "scAddress": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
      "funcName": "getAllESDTTokens",
      "callerAddr": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
      "callValue": "0",
      "args": []
    }),
});

const data = await response.json();

const endpoint = "https://egld.nownodes.io/vm-values/query";
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({
    "scAddress": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
    "funcName": "getAllESDTTokens",
    "callerAddr": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
    "callValue": "0",
    "args": []
  });
console.log(result);

const response = await fetch('https://egld.nownodes.io/vm-values/query', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "scAddress": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
      "funcName": "getAllESDTTokens",
      "callerAddr": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
      "callValue": "0",
      "args": []
    }),
});

const data = await response.json();

import requests

payload = {
  "scAddress": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
  "funcName": "getAllESDTTokens",
  "callerAddr": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
  "callValue": "0",
  "args": []
}

response = requests.post('https://egld.nownodes.io/vm-values/query', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://egld.nownodes.io/vm-values/query')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "scAddress": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
    "funcName": "getAllESDTTokens",
    "callerAddr": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
    "callValue": "0",
    "args": []
  }'

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

Request Body

{
  "scAddress": "erd1qqqqqqqqqqqqqpgq3klgvly2m9qyq3l8d2xst5h4rfv4s5h8jr6q2v4k7a",
  "funcName": "getAllESDTTokens",
  "callerAddr": "erd1qga7ze0l03chfgru0a32wxqf2226nzrxnyhzer9pmdurx0gus0ques3flv",
  "callValue": "0",
  "args": []
}

200

{
  "data": {
    "returnData": [
      "WEGLD-abcdef",
      "MYTOKEN-123456"
    ],
    "returnCode": "ok"
  },
  "error": "",
  "code": "successful"
}

Documentation

How to migrate to NOWNodes

Authentication

REST-API

about

Authorizations

Response

Authorizations

Response

address

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

network

Authorizations

Response

Authorizations

Response

transaction

Authorizations

Body

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

block

Authorizations

Parameters

Response

hyperblock

Authorizations

Parameters

Response

vm-values

Authorizations

Body

Response