TON HTTP API

v2.0.0

Base URL

https://ton.nownodes.io

This API enables HTTP access to TON blockchain - getting accounts and wallets information, looking up blocks and transactions, sending messages to the blockchain, calling get methods of smart contracts, and more.

In addition to REST API, all methods are available through JSON-RPC endpoint with method equal to method name and params passed as a dictionary.

The response contains a JSON object, which always has a boolean field ok and either error or result. If ok equals true, the request was successful and the result of the query can be found in the result field. In case of an unsuccessful request, ok equals false and the error is explained in the error.

API Key should be sent either as api_key query parameter or X-API-Key header.

Authentication

api-keyAuthapiKey

API Key: api-key in header

TON HTTP API

API V1 Reference

Get Address Information

GET

https://ton.nownodes.io/getAddressInformation

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get basic information about the address: balance, code, data, last_transaction_id.

Parameters

addressstringrequiredquery

Identifier of target TON account in any form.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Address Information

curl -X GET 'https://ton.nownodes.io/getAddressInformation'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/getAddressInformation')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Extended Address Information

GET

https://ton.nownodes.io/getExtendedAddressInformation

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Similar to previous one but tries to parse additional information for known contract types. This method is based on tonlib's function getAccountState. For detecting wallets we recommend to use getWalletInformation.

Parameters

addressstringrequiredquery

Identifier of target TON account in any form.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Extended Address Information

curl -X GET 'https://ton.nownodes.io/getExtendedAddressInformation'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/getExtendedAddressInformation')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Wallet Information

GET

https://ton.nownodes.io/getWalletInformation

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieve wallet information. This method parses contract state and currently supports more wallet types than getExtendedAddressInformation: simple wallet, standart wallet, v3 wallet, v4 wallet.

Parameters

addressstringrequiredquery

Identifier of target TON account in any form.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Wallet Information

curl -X GET 'https://ton.nownodes.io/getWalletInformation'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/getWalletInformation')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Transactions

GET

https://ton.nownodes.io/getTransactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get transaction history of a given address.

Parameters

addressstringrequiredquery

Identifier of target TON account in any form.

limitinteger<= 10010query

Maximum number of transactions in response.

ltintegerquery

Logical time of transaction to start with, must be sent with hash.

hashstringquery

Hash of transaction to start with, in base64 or hex encoding , must be sent with lt.

to_ltinteger0query

Logical time of transaction to finish with (to get tx from lt to to_lt).

archivalbooleanfalsequery

By default getTransaction request is processed by any available liteserver. If archival=true only liteservers with full history are used.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Transactions

curl -X GET 'https://ton.nownodes.io/getTransactions'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/getTransactions')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Address Balance

GET

https://ton.nownodes.io/getAddressBalance

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get balance (in nanotons) of a given address.

Parameters

addressstringrequiredquery

Identifier of target TON account in any form.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Address Balance

curl -X GET 'https://ton.nownodes.io/getAddressBalance'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/getAddressBalance')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Address

GET

https://ton.nownodes.io/getAddressState

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get state of a given address. State can be either unitialized, active or frozen.

Parameters

addressstringrequiredquery

Identifier of target TON account in any form.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Address

curl -X GET 'https://ton.nownodes.io/getAddressState'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/getAddressState')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Pack Address

GET

https://ton.nownodes.io/packAddress

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Convert an address from raw to human-readable format.

Parameters

addressstringrequiredquery

Identifier of target TON account in raw form.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Pack Address

curl -X GET 'https://ton.nownodes.io/packAddress'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/packAddress')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Unpack Address

GET

https://ton.nownodes.io/unpackAddress

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Convert an address from human-readable to raw format.

Parameters

addressstringrequiredquery

Identifier of target TON account in user-friendly form

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Unpack Address

curl -X GET 'https://ton.nownodes.io/unpackAddress'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/unpackAddress')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Masterchain Info

GET

https://ton.nownodes.io/getMasterchainInfo

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get up-to-date masterchain state.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Masterchain Info

curl -X GET 'https://ton.nownodes.io/getMasterchainInfo'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/getMasterchainInfo')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Masterchain Block Signatures

GET

https://ton.nownodes.io/getMasterchainBlockSignatures

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get up-to-date masterchain state.

Parameters

seqnointegerrequiredquery

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Masterchain Block Signatures

curl -X GET 'https://ton.nownodes.io/getMasterchainBlockSignatures'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/getMasterchainBlockSignatures')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Shard Block Proof

GET

https://ton.nownodes.io/getShardBlockProof

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get merkle proof of shardchain block.

Parameters

workchainintegerrequiredquery

Block workchain id

shardintegerrequiredquery

Block shard id

seqnointegerrequiredquery

Block seqno

from_seqnointegerquery

Seqno of masterchain block starting from which proof is required. If not specified latest masterchain block is used.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Shard Block Proof

curl -X GET 'https://ton.nownodes.io/getShardBlockProof'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/getShardBlockProof')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Consensus Block

GET

https://ton.nownodes.io/getConsensusBlock

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get consensus block and its update timestamp.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Consensus Block

curl -X GET 'https://ton.nownodes.io/getConsensusBlock'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/getConsensusBlock')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Lookup Block

GET

https://ton.nownodes.io/lookupBlock

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Look up block by either seqno, lt or unixtime.

Parameters

workchainintegerrequiredquery

Workchain id to look up block in

shardintegerrequiredquery

Shard id to look up block in

seqnointegerquery

Block's height

ltintegerquery

Block's logical time

unixtimeintegerquery

Block's unixtime

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Lookup Block

curl -X GET 'https://ton.nownodes.io/lookupBlock'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/lookupBlock')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Shards

GET

https://ton.nownodes.io/shards

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get shards information.

Parameters

seqnointegerrequiredquery

Masterchain seqno to fetch shards of.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Shards

curl -X GET 'https://ton.nownodes.io/shards'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/shards')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Block Transactions

GET

https://ton.nownodes.io/getBlockTransactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get transactions of the given block.

Parameters

workchainintegerrequiredquery

shardintegerrequiredquery

seqnointegerrequiredquery

root_hashstringquery

file_hashstringquery

after_ltintegerquery

after_hashstringquery

countinteger40query

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Block Transactions

curl -X GET 'https://ton.nownodes.io/getBlockTransactions'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/getBlockTransactions')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Block Transactions Ext

GET

https://ton.nownodes.io/getBlockTransactionsExt

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get transactions of the given block.

Parameters

workchainintegerrequiredquery

shardintegerrequiredquery

seqnointegerrequiredquery

root_hashstringquery

file_hashstringquery

after_ltintegerquery

after_hashstringquery

countinteger40query

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Block Transactions Ext

curl -X GET 'https://ton.nownodes.io/getBlockTransactionsExt'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/getBlockTransactionsExt')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Block Header

GET

https://ton.nownodes.io/getBlockHeader

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get metadata of a given block.

Parameters

workchainintegerrequiredquery

shardintegerrequiredquery

seqnointegerrequiredquery

root_hashstringquery

file_hashstringquery

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Block Header

curl -X GET 'https://ton.nownodes.io/getBlockHeader'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/getBlockHeader')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Config Param

GET

https://ton.nownodes.io/getConfigParam

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get config by id.

Parameters

config_idintegerrequiredquery

Config id

seqnointegerquery

Masterchain seqno. If not specified, latest blockchain state will be used.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Config Param

curl -X GET 'https://ton.nownodes.io/getConfigParam'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/getConfigParam')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Config All

GET

https://ton.nownodes.io/getConfigAll

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get cell with full config.

Parameters

seqnointegerquery

Masterchain seqno. If not specified, latest blockchain state will be used.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Config All

curl -X GET 'https://ton.nownodes.io/getConfigAll'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/getConfigAll')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Out Msg Queue Sizes

GET

https://ton.nownodes.io/getOutMsgQueueSizes

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get info with current sizes of messages queues by shards.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Out Msg Queue Sizes

curl -X GET 'https://ton.nownodes.io/getOutMsgQueueSizes'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/getOutMsgQueueSizes')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Token Data

GET

https://ton.nownodes.io/getTokenData

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get NFT or Jetton information.

Parameters

addressstringrequiredquery

Address of NFT collection/item or Jetton master/wallet smart contract

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Token Data

curl -X GET 'https://ton.nownodes.io/getTokenData'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/getTokenData')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Try Locate Tx

GET

https://ton.nownodes.io/tryLocateTx

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Locate outcoming transaction of destination address by incoming message.

Parameters

sourcestringrequiredquery

destinationstringrequiredquery

created_ltintegerrequiredquery

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Try Locate Tx

curl -X GET 'https://ton.nownodes.io/tryLocateTx'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/tryLocateTx')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Try Locate Result Tx

GET

https://ton.nownodes.io/tryLocateResultTx

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Same as previous. Locate outcoming transaction of destination address by incoming message

Parameters

sourcestringrequiredquery

destinationstringrequiredquery

created_ltintegerrequiredquery

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Try Locate Result Tx

curl -X GET 'https://ton.nownodes.io/tryLocateResultTx'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/tryLocateResultTx')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Get Try Locate Source Tx

GET

https://ton.nownodes.io/tryLocateSourceTx

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Locate incoming transaction of source address by outcoming message.

Parameters

sourcestringrequiredquery

destinationstringrequiredquery

created_ltintegerrequiredquery

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Get Try Locate Source Tx

curl -X GET 'https://ton.nownodes.io/tryLocateSourceTx'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/tryLocateSourceTx')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Detect Address

GET

https://ton.nownodes.io/detectAddress

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get all possible address forms.

Parameters

addressstringrequiredquery

Identifier of target TON account in any form.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Detect Address

curl -X GET 'https://ton.nownodes.io/detectAddress'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton.nownodes.io/detectAddress')
data = response.json()

require 'net/http'
require 'json'

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

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Send Boc

POST

https://ton.nownodes.io/sendBoc

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Send serialized boc file: fully packed and serialized external message to blockchain.

Body

application/json

bocstringrequired

b64 encoded bag of cells

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Send Boc

curl -X POST 'https://ton.nownodes.io/sendBoc' \
  -H 'Content-Type: application/json' \
  -d '{
    "boc": "string"
  }'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ton.nownodes.io/sendBoc')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "boc": "string"
  }'

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

import requests

payload = {
  "boc": "string"
}

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

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

const data = await response.json();

const endpoint = "https://ton.nownodes.io/sendBoc";
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({
    "boc": "string"
  });
console.log(result);

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

const data = await response.json();

import requests

payload = {
  "boc": "string"
}

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

require 'net/http'
require 'json'

uri = URI('https://ton.nownodes.io/sendBoc')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "boc": "string"
  }'

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

Request Body

{
  "boc": "string"
}

200

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Send Boc Return Hash

POST

https://ton.nownodes.io/sendBocReturnHash

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Send serialized boc file: fully packed and serialized external message to blockchain. The method returns message hash.

Body

application/json

bocstringrequired

b64 encoded bag of cells

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Send Boc Return Hash

curl -X POST 'https://ton.nownodes.io/sendBocReturnHash' \
  -H 'Content-Type: application/json' \
  -d '{
    "boc": "string"
  }'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ton.nownodes.io/sendBocReturnHash')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "boc": "string"
  }'

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

import requests

payload = {
  "boc": "string"
}

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

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

const data = await response.json();

const endpoint = "https://ton.nownodes.io/sendBocReturnHash";
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({
    "boc": "string"
  });
console.log(result);

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

const data = await response.json();

import requests

payload = {
  "boc": "string"
}

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

require 'net/http'
require 'json'

uri = URI('https://ton.nownodes.io/sendBocReturnHash')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "boc": "string"
  }'

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

Request Body

{
  "boc": "string"
}

200

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Send Query

POST

https://ton.nownodes.io/sendQuery

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Send query - unpacked external message. This method takes address, body and init-params (if any), packs it to external message and sends to network. All params should be boc-serialized.

Body

application/json

addressstringrequired

Address in any format

bodystringrequired

b64-encoded boc-serialized cell with message body

init_codestring

b64-encoded boc-serialized cell with init-code

init_datastring

b64-encoded boc-serialized cell with init-data

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Send Query

curl -X POST 'https://ton.nownodes.io/sendQuery' \
  -H 'Content-Type: application/json' \
  -d '{
    "address": "string",
    "body": "string",
    "init_code": "",
    "init_data": ""
  }'

const response = await fetch('https://ton.nownodes.io/sendQuery', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "string",
      "body": "string",
      "init_code": "",
      "init_data": ""
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ton.nownodes.io/sendQuery')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "string",
    "body": "string",
    "init_code": "",
    "init_data": ""
  }'

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

import requests

payload = {
  "address": "string",
  "body": "string",
  "init_code": "",
  "init_data": ""
}

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

const response = await fetch('https://ton.nownodes.io/sendQuery', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "string",
      "body": "string",
      "init_code": "",
      "init_data": ""
    }),
});

const data = await response.json();

const endpoint = "https://ton.nownodes.io/sendQuery";
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({
    "address": "string",
    "body": "string",
    "init_code": "",
    "init_data": ""
  });
console.log(result);

const response = await fetch('https://ton.nownodes.io/sendQuery', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "string",
      "body": "string",
      "init_code": "",
      "init_data": ""
    }),
});

const data = await response.json();

import requests

payload = {
  "address": "string",
  "body": "string",
  "init_code": "",
  "init_data": ""
}

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

require 'net/http'
require 'json'

uri = URI('https://ton.nownodes.io/sendQuery')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "string",
    "body": "string",
    "init_code": "",
    "init_data": ""
  }'

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

Request Body

{
  "address": "string",
  "body": "string",
  "init_code": "",
  "init_data": ""
}

200

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Estimate Fee

POST

https://ton.nownodes.io/estimateFee

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Estimate fees required for query processing. body, init-code and init-data accepted in serialized format (b64-encoded).

Body

application/json

addressstringrequired

Address in any format

bodystringrequired

b64-encoded cell with message body

init_codestring

b64-encoded cell with init-code

init_datastring

b64-encoded cell with init-data

ignore_chksigbooleantrue

If true during test query processing assume that all chksig operations return True

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Estimate Fee

curl -X POST 'https://ton.nownodes.io/estimateFee' \
  -H 'Content-Type: application/json' \
  -d '{
    "address": "string",
    "body": "string",
    "init_code": "",
    "init_data": "",
    "ignore_chksig": true
  }'

const response = await fetch('https://ton.nownodes.io/estimateFee', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "string",
      "body": "string",
      "init_code": "",
      "init_data": "",
      "ignore_chksig": true
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ton.nownodes.io/estimateFee')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "string",
    "body": "string",
    "init_code": "",
    "init_data": "",
    "ignore_chksig": true
  }'

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

import requests

payload = {
  "address": "string",
  "body": "string",
  "init_code": "",
  "init_data": "",
  "ignore_chksig": True
}

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

const response = await fetch('https://ton.nownodes.io/estimateFee', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "string",
      "body": "string",
      "init_code": "",
      "init_data": "",
      "ignore_chksig": true
    }),
});

const data = await response.json();

const endpoint = "https://ton.nownodes.io/estimateFee";
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({
    "address": "string",
    "body": "string",
    "init_code": "",
    "init_data": "",
    "ignore_chksig": true
  });
console.log(result);

const response = await fetch('https://ton.nownodes.io/estimateFee', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "string",
      "body": "string",
      "init_code": "",
      "init_data": "",
      "ignore_chksig": true
    }),
});

const data = await response.json();

import requests

payload = {
  "address": "string",
  "body": "string",
  "init_code": "",
  "init_data": "",
  "ignore_chksig": True
}

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

require 'net/http'
require 'json'

uri = URI('https://ton.nownodes.io/estimateFee')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "string",
    "body": "string",
    "init_code": "",
    "init_data": "",
    "ignore_chksig": true
  }'

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

Request Body

{
  "address": "string",
  "body": "string",
  "init_code": "",
  "init_data": "",
  "ignore_chksig": true
}

200

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Run Get Method

POST

https://ton.nownodes.io/runGetMethod

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Run get method on smart contract.

Body

application/json

addressstringrequired

Contract address

methodstring | integerrequired

Method name or method id

stackArray<Array<any>>required

Array of stack elements: [['num',3], ['cell', cell_object], ['slice', slice_object]]

seqnointeger

Seqno of masterchain block at which moment the Get Method is to be executed

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Run Get Method

curl -X POST 'https://ton.nownodes.io/runGetMethod' \
  -H 'Content-Type: application/json' \
  -d '{
    "address": "string",
    "method": "string",
    "stack": [
      []
    ],
    "seqno": 0
  }'

import { JsonRpcProvider } from "ethers";

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

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

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

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

puts JSON.parse(response.body)

from web3 import Web3

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

import { createPublicClient, http } from "viem";

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

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

console.log(result);

const endpoint = "https://ton.nownodes.io/runGetMethod";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ton.nownodes.io/runGetMethod', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "string",
      "method": "string",
      "stack": [
        []
      ],
      "seqno": 0
    }),
});

const data = await response.json();

import requests

payload = {
  "address": "string",
  "method": "string",
  "stack": [
    []
  ],
  "seqno": 0
}

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

require 'net/http'
require 'json'

uri = URI('https://ton.nownodes.io/runGetMethod')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "string",
    "method": "string",
    "stack": [
      []
    ],
    "seqno": 0
  }'

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

Request Body

{
  "address": "string",
  "method": "string",
  "stack": [
    []
  ],
  "seqno": 0
}

200

{
  "ok": true,
  "result": "string",
  "error": "string",
  "code": 0
}

Jsonrpc Handler

POST

https://ton.nownodes.io/jsonRPC

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

All methods in the API are available through JSON-RPC protocol (spec).

Body

application/json

methodstringrequired

paramsobject[object Object]

idstring

jsonrpcstring

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

504Gateway Timeout

Lite Server Timeout

Jsonrpc Handler

curl -X POST 'https://ton.nownodes.io/jsonRPC' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "string",
    "params": {},
    "id": "string",
    "jsonrpc": "string"
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://ton.nownodes.io/jsonRPC");
const result = await provider.send("string", {});
console.log(result);

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

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

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

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://ton.nownodes.io/jsonRPC"))
response = w3.provider.make_request("string", {})
print(response)

import { createPublicClient, http } from "viem";

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

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

console.log(result);

const endpoint = "https://ton.nownodes.io/jsonRPC";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

payload = {
  "method": "string",
  "params": {},
  "id": "string",
  "jsonrpc": "string"
}

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

require 'net/http'
require 'json'

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

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

Request Body

{
  "method": "string",
  "params": {},
  "id": "string",
  "jsonrpc": "string"
}

200

{
  "ok": true,
  "error": "string",
  "code": 0,
  "id": "string",
  "jsonrpc": "2.0"
}

Documentation

How to migrate to NOWNodes

Authentication

TON HTTP API

API V1 Reference

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

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

Parameters

Response

Authorizations

Body

Response