TON Index (mainnet)

v1.0.0

Base URL

https://ton-index.nownodes.io

TON Index collects data from a full node to PostgreSQL database and provides convenient API to an indexed blockchain.

Authentication

api-keyAuthapiKey

API Key: api-key in header

TON Index (mainnet)

API V3 Reference (Index)

Get Masterchain Info

GET

https://ton-index.nownodes.io/masterchainInfo

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get up-to-date masterchain state.

Response

200OK

Successful Response

Get Masterchain Info

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

{
  "last": {
    "workchain": 0,
    "shard": "string",
    "seqno": 0,
    "root_hash": "string",
    "file_hash": "string",
    "global_id": 0,
    "version": 0,
    "after_merge": true,
    "before_split": true,
    "after_split": true,
    "want_merge": true,
    "want_split": true,
    "key_block": true,
    "vert_seqno_incr": true,
    "flags": 0,
    "gen_utime": "string",
    "start_lt": "string",
    "end_lt": "string",
    "validator_list_hash_short": 0,
    "gen_catchain_seqno": 0,
    "min_ref_mc_seqno": 0,
    "prev_key_block_seqno": 0,
    "vert_seqno": 0,
    "master_ref_seqno": 0,
    "rand_seed": "string",
    "created_by": "string",
    "tx_count": 0,
    "masterchain_block_ref": {
      "workchain": 0,
      "shard": "string",
      "seqno": 0
    },
    "prev_blocks": [
      {
        "workchain": 0,
        "shard": "string",
        "seqno": 0
      }
    ]
  },
  "first": {
    "workchain": 0,
    "shard": "string",
    "seqno": 0,
    "root_hash": "string",
    "file_hash": "string",
    "global_id": 0,
    "version": 0,
    "after_merge": true,
    "before_split": true,
    "after_split": true,
    "want_merge": true,
    "want_split": true,
    "key_block": true,
    "vert_seqno_incr": true,
    "flags": 0,
    "gen_utime": "string",
    "start_lt": "string",
    "end_lt": "string",
    "validator_list_hash_short": 0,
    "gen_catchain_seqno": 0,
    "min_ref_mc_seqno": 0,
    "prev_key_block_seqno": 0,
    "vert_seqno": 0,
    "master_ref_seqno": 0,
    "rand_seed": "string",
    "created_by": "string",
    "tx_count": 0,
    "masterchain_block_ref": {
      "workchain": 0,
      "shard": "string",
      "seqno": 0
    },
    "prev_blocks": [
      {
        "workchain": 0,
        "shard": "string",
        "seqno": 0
      }
    ]
  }
}

Get Blocks

GET

https://ton-index.nownodes.io/blocks

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns blocks by specified filters.

Parameters

workchainintegerquery

Block workchain.

shardstringquery

Block shard id. Must be sent with workchain. Example: 8000000000000000

seqnointegerquery

Block block seqno. Must be sent with workchain and shard.

start_utimeintegerquery

Query blocks with generation UTC timestamp after given timestamp.

end_utimeintegerquery

Query blocks with generation UTC timestamp before given timestamp

start_ltintegerquery

Query blocks with lt >= start_lt

end_ltintegerquery

Query blocks with lt <= end_lt

limitinteger[1, 256]128query

Limit number of queried rows. Use with offset to batch read.

offsetinteger>= 00query

Skip first N rows. Use with limit to batch read.

sortstringascdescdescquery

Sort results by UTC timestamp.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Blocks

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/blocks')
request = Net::HTTP::Get.new(uri)

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

import requests

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

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

const data = await response.json();

const endpoint = "https://ton-index.nownodes.io/blocks";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/blocks')
request = Net::HTTP::Get.new(uri)

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

{
  "blocks": [
    {
      "workchain": 0,
      "shard": "string",
      "seqno": 0,
      "root_hash": "string",
      "file_hash": "string",
      "global_id": 0,
      "version": 0,
      "after_merge": true,
      "before_split": true,
      "after_split": true,
      "want_merge": true,
      "want_split": true,
      "key_block": true,
      "vert_seqno_incr": true,
      "flags": 0,
      "gen_utime": "string",
      "start_lt": "string",
      "end_lt": "string",
      "validator_list_hash_short": 0,
      "gen_catchain_seqno": 0,
      "min_ref_mc_seqno": 0,
      "prev_key_block_seqno": 0,
      "vert_seqno": 0,
      "master_ref_seqno": 0,
      "rand_seed": "string",
      "created_by": "string",
      "tx_count": 0,
      "masterchain_block_ref": {
        "workchain": 0,
        "shard": "string",
        "seqno": 0
      },
      "prev_blocks": [
        {
          "workchain": 0,
          "shard": "string",
          "seqno": 0
        }
      ]
    }
  ]
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Shards By Masterchain Block

GET

https://ton-index.nownodes.io/masterchainBlockShardState

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

seqnointegerrequiredquery

Masterchain block seqno

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Shards By Masterchain Block

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/masterchainBlockShardState')
request = Net::HTTP::Get.new(uri)

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

{
  "blocks": [
    {
      "workchain": 0,
      "shard": "string",
      "seqno": 0,
      "root_hash": "string",
      "file_hash": "string",
      "global_id": 0,
      "version": 0,
      "after_merge": true,
      "before_split": true,
      "after_split": true,
      "want_merge": true,
      "want_split": true,
      "key_block": true,
      "vert_seqno_incr": true,
      "flags": 0,
      "gen_utime": "string",
      "start_lt": "string",
      "end_lt": "string",
      "validator_list_hash_short": 0,
      "gen_catchain_seqno": 0,
      "min_ref_mc_seqno": 0,
      "prev_key_block_seqno": 0,
      "vert_seqno": 0,
      "master_ref_seqno": 0,
      "rand_seed": "string",
      "created_by": "string",
      "tx_count": 0,
      "masterchain_block_ref": {
        "workchain": 0,
        "shard": "string",
        "seqno": 0
      },
      "prev_blocks": [
        {
          "workchain": 0,
          "shard": "string",
          "seqno": 0
        }
      ]
    }
  ]
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Address Book

GET

https://ton-index.nownodes.io/addressBook

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an address book for given address list.

Parameters

addressArray<string>requiredquery

List of addresses in any form. Max: 1024

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Address Book

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/addressBook')
request = Net::HTTP::Get.new(uri)

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

{}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Masterchain Block Shards

GET

https://ton-index.nownodes.io/masterchainBlockShards

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all worchain blocks, that appeared after previous masterchain block.

Note: this method is not equivalent with /api/v2/shards.

Parameters

seqnointegerrequiredquery

Masterchain block seqno

include_mc_blockbooleanfalsequery

Include masterchain block

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Masterchain Block Shards

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/masterchainBlockShards')
request = Net::HTTP::Get.new(uri)

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

{
  "blocks": [
    {
      "workchain": 0,
      "shard": "string",
      "seqno": 0,
      "root_hash": "string",
      "file_hash": "string",
      "global_id": 0,
      "version": 0,
      "after_merge": true,
      "before_split": true,
      "after_split": true,
      "want_merge": true,
      "want_split": true,
      "key_block": true,
      "vert_seqno_incr": true,
      "flags": 0,
      "gen_utime": "string",
      "start_lt": "string",
      "end_lt": "string",
      "validator_list_hash_short": 0,
      "gen_catchain_seqno": 0,
      "min_ref_mc_seqno": 0,
      "prev_key_block_seqno": 0,
      "vert_seqno": 0,
      "master_ref_seqno": 0,
      "rand_seed": "string",
      "created_by": "string",
      "tx_count": 0,
      "masterchain_block_ref": {
        "workchain": 0,
        "shard": "string",
        "seqno": 0
      },
      "prev_blocks": [
        {
          "workchain": 0,
          "shard": "string",
          "seqno": 0
        }
      ]
    }
  ]
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Transactions

GET

https://ton-index.nownodes.io/transactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get transactions by specified filters.

Parameters

workchainintegerquery

Block workchain.

shardstringquery

Block shard id. Must be sent with workchain. Example: 8000000000000000

seqnointegerquery

Block block seqno. Must be sent with workchain and shard. Must be sent in hex form.

accountArray<string>query

List of account addresses to get transactions. Can be sent in hex, base64 or base64url form.

exclude_accountArray<string>query

Exclude transactions on specified account addresses

hashstringquery

Transaction hash. Acceptable in hex, base64 and base64url forms.

ltintegerquery

Transaction lt.

start_utimeintegerquery

Query transactions with generation UTC timestamp after given timestamp.

end_utimeintegerquery

Query transactions with generation UTC timestamp before given timestamp

start_ltintegerquery

Query transactions with lt >= start_lt

end_ltintegerquery

Query transactions with lt <= end_lt

limitinteger[1, 256]128query

Limit number of queried rows. Use with offset to batch read.

offsetinteger>= 00query

Skip first N rows. Use with limit to batch read.

sortstringascdescdescquery

Sort transactions by lt.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Transactions

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/transactions')
request = Net::HTTP::Get.new(uri)

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

{
  "transactions": [
    {
      "account": "string",
      "hash": "string",
      "lt": "string",
      "now": 0,
      "orig_status": "uninit",
      "end_status": "uninit",
      "total_fees": "string",
      "prev_trans_hash": "string",
      "prev_trans_lt": "string",
      "block_ref": {
        "workchain": 0,
        "shard": "string",
        "seqno": 0
      },
      "in_msg": {
        "hash": "string",
        "source": "string",
        "destination": "string",
        "value": "string",
        "fwd_fee": "string",
        "ihr_fee": "string",
        "created_lt": "string",
        "created_at": "string",
        "opcode": "string",
        "ihr_disabled": true,
        "bounce": true,
        "bounced": true,
        "import_fee": "string",
        "message_content": {
          "hash": "string",
          "body": "string",
          "decoded": {
            "type": "text_comment",
            "comment": "string"
          }
        },
        "init_state": {
          "hash": "string",
          "body": "string"
        }
      },
      "out_msgs": [
        {
          "hash": "string",
          "source": "string",
          "destination": "string",
          "value": "string",
          "fwd_fee": "string",
          "ihr_fee": "string",
          "created_lt": "string",
          "created_at": "string",
          "opcode": "string",
          "ihr_disabled": true,
          "bounce": true,
          "bounced": true,
          "import_fee": "string",
          "message_content": {
            "hash": "string",
            "body": "string",
            "decoded": {
              "type": "text_comment",
              "comment": "string"
            }
          },
          "init_state": {
            "hash": "string",
            "body": "string"
          }
        }
      ],
      "account_state_before": {
        "hash": "string",
        "balance": "string",
        "account_status": "uninit",
        "frozen_hash": "string",
        "code_hash": "string",
        "data_hash": "string"
      },
      "account_state_after": {
        "hash": "string",
        "balance": "string",
        "account_status": "uninit",
        "frozen_hash": "string",
        "code_hash": "string",
        "data_hash": "string"
      },
      "mc_block_seqno": 0
    }
  ],
  "address_book": {}
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Transactions By Masterchain Block

GET

https://ton-index.nownodes.io/transactionsByMasterchainBlock

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns transactions from masterchain block and from all shards.

Parameters

seqnointegerrequiredquery

Masterchain block seqno

limitinteger[1, 256]128query

Limit number of queried rows. Use with offset to batch read.

offsetinteger>= 00query

Skip first N rows. Use with limit to batch read.

sortstringnoneascdescdescquery

Sort transactions by lt.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Transactions By Masterchain Block

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/transactionsByMasterchainBlock')
request = Net::HTTP::Get.new(uri)

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

{
  "transactions": [
    {
      "account": "string",
      "hash": "string",
      "lt": "string",
      "now": 0,
      "orig_status": "uninit",
      "end_status": "uninit",
      "total_fees": "string",
      "prev_trans_hash": "string",
      "prev_trans_lt": "string",
      "block_ref": {
        "workchain": 0,
        "shard": "string",
        "seqno": 0
      },
      "in_msg": {
        "hash": "string",
        "source": "string",
        "destination": "string",
        "value": "string",
        "fwd_fee": "string",
        "ihr_fee": "string",
        "created_lt": "string",
        "created_at": "string",
        "opcode": "string",
        "ihr_disabled": true,
        "bounce": true,
        "bounced": true,
        "import_fee": "string",
        "message_content": {
          "hash": "string",
          "body": "string",
          "decoded": {
            "type": "text_comment",
            "comment": "string"
          }
        },
        "init_state": {
          "hash": "string",
          "body": "string"
        }
      },
      "out_msgs": [
        {
          "hash": "string",
          "source": "string",
          "destination": "string",
          "value": "string",
          "fwd_fee": "string",
          "ihr_fee": "string",
          "created_lt": "string",
          "created_at": "string",
          "opcode": "string",
          "ihr_disabled": true,
          "bounce": true,
          "bounced": true,
          "import_fee": "string",
          "message_content": {
            "hash": "string",
            "body": "string",
            "decoded": {
              "type": "text_comment",
              "comment": "string"
            }
          },
          "init_state": {
            "hash": "string",
            "body": "string"
          }
        }
      ],
      "account_state_before": {
        "hash": "string",
        "balance": "string",
        "account_status": "uninit",
        "frozen_hash": "string",
        "code_hash": "string",
        "data_hash": "string"
      },
      "account_state_after": {
        "hash": "string",
        "balance": "string",
        "account_status": "uninit",
        "frozen_hash": "string",
        "code_hash": "string",
        "data_hash": "string"
      },
      "mc_block_seqno": 0
    }
  ],
  "address_book": {}
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Transactions By Message

GET

https://ton-index.nownodes.io/transactionsByMessage

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get transactions whose inbound/outbound message has the specified hash. This endpoint returns list of Transaction objects since collisions of message hashes can occur.

Parameters

directionstringinoutrequiredquery

Message direction.

msg_hashstringrequiredquery

Message hash. Acceptable in hex, base64 and base64url forms.

limitinteger[1, 256]128query

Limit number of queried rows. Use with offset to batch read.

offsetinteger>= 00query

Skip first N rows. Use with limit to batch read.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Transactions By Message

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/transactionsByMessage')
request = Net::HTTP::Get.new(uri)

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

{
  "transactions": [
    {
      "account": "string",
      "hash": "string",
      "lt": "string",
      "now": 0,
      "orig_status": "uninit",
      "end_status": "uninit",
      "total_fees": "string",
      "prev_trans_hash": "string",
      "prev_trans_lt": "string",
      "block_ref": {
        "workchain": 0,
        "shard": "string",
        "seqno": 0
      },
      "in_msg": {
        "hash": "string",
        "source": "string",
        "destination": "string",
        "value": "string",
        "fwd_fee": "string",
        "ihr_fee": "string",
        "created_lt": "string",
        "created_at": "string",
        "opcode": "string",
        "ihr_disabled": true,
        "bounce": true,
        "bounced": true,
        "import_fee": "string",
        "message_content": {
          "hash": "string",
          "body": "string",
          "decoded": {
            "type": "text_comment",
            "comment": "string"
          }
        },
        "init_state": {
          "hash": "string",
          "body": "string"
        }
      },
      "out_msgs": [
        {
          "hash": "string",
          "source": "string",
          "destination": "string",
          "value": "string",
          "fwd_fee": "string",
          "ihr_fee": "string",
          "created_lt": "string",
          "created_at": "string",
          "opcode": "string",
          "ihr_disabled": true,
          "bounce": true,
          "bounced": true,
          "import_fee": "string",
          "message_content": {
            "hash": "string",
            "body": "string",
            "decoded": {
              "type": "text_comment",
              "comment": "string"
            }
          },
          "init_state": {
            "hash": "string",
            "body": "string"
          }
        }
      ],
      "account_state_before": {
        "hash": "string",
        "balance": "string",
        "account_status": "uninit",
        "frozen_hash": "string",
        "code_hash": "string",
        "data_hash": "string"
      },
      "account_state_after": {
        "hash": "string",
        "balance": "string",
        "account_status": "uninit",
        "frozen_hash": "string",
        "code_hash": "string",
        "data_hash": "string"
      },
      "mc_block_seqno": 0
    }
  ],
  "address_book": {}
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Adjacent Transactions

GET

https://ton-index.nownodes.io/adjacentTransactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get parent and/or children for specified transaction.

Parameters

hashstringrequiredquery

Transaction hash. Acceptable in hex, base64 and base64url forms.

directionstringinoutbothbothquery

Direction transactions by lt.

limitinteger[1, 256]128query

Limit number of queried rows. Use with offset to batch read.

offsetinteger>= 00query

Skip first N rows. Use with limit to batch read.

sortstringnoneascdescdescquery

Sort transactions by lt.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Adjacent Transactions

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/adjacentTransactions')
request = Net::HTTP::Get.new(uri)

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

{
  "transactions": [
    {
      "account": "string",
      "hash": "string",
      "lt": "string",
      "now": 0,
      "orig_status": "uninit",
      "end_status": "uninit",
      "total_fees": "string",
      "prev_trans_hash": "string",
      "prev_trans_lt": "string",
      "block_ref": {
        "workchain": 0,
        "shard": "string",
        "seqno": 0
      },
      "in_msg": {
        "hash": "string",
        "source": "string",
        "destination": "string",
        "value": "string",
        "fwd_fee": "string",
        "ihr_fee": "string",
        "created_lt": "string",
        "created_at": "string",
        "opcode": "string",
        "ihr_disabled": true,
        "bounce": true,
        "bounced": true,
        "import_fee": "string",
        "message_content": {
          "hash": "string",
          "body": "string",
          "decoded": {
            "type": "text_comment",
            "comment": "string"
          }
        },
        "init_state": {
          "hash": "string",
          "body": "string"
        }
      },
      "out_msgs": [
        {
          "hash": "string",
          "source": "string",
          "destination": "string",
          "value": "string",
          "fwd_fee": "string",
          "ihr_fee": "string",
          "created_lt": "string",
          "created_at": "string",
          "opcode": "string",
          "ihr_disabled": true,
          "bounce": true,
          "bounced": true,
          "import_fee": "string",
          "message_content": {
            "hash": "string",
            "body": "string",
            "decoded": {
              "type": "text_comment",
              "comment": "string"
            }
          },
          "init_state": {
            "hash": "string",
            "body": "string"
          }
        }
      ],
      "account_state_before": {
        "hash": "string",
        "balance": "string",
        "account_status": "uninit",
        "frozen_hash": "string",
        "code_hash": "string",
        "data_hash": "string"
      },
      "account_state_after": {
        "hash": "string",
        "balance": "string",
        "account_status": "uninit",
        "frozen_hash": "string",
        "code_hash": "string",
        "data_hash": "string"
      },
      "mc_block_seqno": 0
    }
  ],
  "address_book": {}
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Messages

GET

https://ton-index.nownodes.io/messages

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get messages by specified filters.

Parameters

hashstringquery

Message hash. Acceptable in hex, base64 and base64url forms.

sourcestringquery

The source account address. Can be sent in hex, base64 or base64url form. Use value null to get external messages.

destinationstringquery

The destination account address. Can be sent in hex, base64 or base64url form. Use value null to get log messages.

body_hashstringquery

Message body hash. Acceptable in hex, base64 and base64url forms.

limitinteger[1, 256]128query

Limit number of queried rows. Use with offset to batch read.

offsetinteger>= 00query

Skip first N rows. Use with limit to batch read.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Messages

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/messages')
request = Net::HTTP::Get.new(uri)

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

{
  "messages": [
    {
      "hash": "string",
      "source": "string",
      "destination": "string",
      "value": "string",
      "fwd_fee": "string",
      "ihr_fee": "string",
      "created_lt": "string",
      "created_at": "string",
      "opcode": "string",
      "ihr_disabled": true,
      "bounce": true,
      "bounced": true,
      "import_fee": "string",
      "message_content": {
        "hash": "string",
        "body": "string",
        "decoded": {
          "type": "text_comment",
          "comment": "string"
        }
      },
      "init_state": {
        "hash": "string",
        "body": "string"
      }
    }
  ]
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Nft Collections

GET

https://ton-index.nownodes.io/nft/collections

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get NFT collections.

Parameters

collection_addressstringquery

NFT collection address. Must be sent in hex, base64 and base64url forms.

owner_addressstringquery

Address of NFT collection owner. Must be sent in hex, base64 and base64url forms.

limitinteger[1, 256]128query

Limit number of queried rows. Use with offset to batch read.

offsetinteger>= 00query

Skip first N rows. Use with limit to batch read.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Nft Collections

curl -X GET 'https://ton-index.nownodes.io/nft/collections'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton-index.nownodes.io/nft/collections')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/nft/collections')
request = Net::HTTP::Get.new(uri)

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

{
  "nft_collections": [
    {
      "address": "string",
      "owner_address": "string",
      "last_transaction_lt": "string",
      "next_item_index": "string",
      "code_hash": "string",
      "data_hash": "string"
    }
  ]
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Nft Items

GET

https://ton-index.nownodes.io/nft/items

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get NFT items.

Parameters

addressstringquery

NFT address. Must be sent in hex, base64 and base64url forms.

owner_addressstringquery

Address of NFT owner. Must be sent in hex, base64 and base64url forms.

collection_addressstringquery

NFT collection address. Must be sent in hex, base64 and base64url forms.

indexstringquery

NFT Item index. Use it together with collection address.

limitinteger[1, 256]128query

Limit number of queried rows. Use with offset to batch read.

offsetinteger>= 00query

Skip first N rows. Use with limit to batch read.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Nft Items

curl -X GET 'https://ton-index.nownodes.io/nft/items'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton-index.nownodes.io/nft/items')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/nft/items')
request = Net::HTTP::Get.new(uri)

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

{
  "nft_items": [
    {
      "address": "string",
      "collection_address": "string",
      "owner_address": "string",
      "init": true,
      "index": "string",
      "last_transaction_lt": "string",
      "code_hash": "string",
      "data_hash": "string",
      "collection": {
        "address": "string",
        "owner_address": "string",
        "last_transaction_lt": "string",
        "next_item_index": "string",
        "code_hash": "string",
        "data_hash": "string"
      }
    }
  ]
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Nft Transfers

GET

https://ton-index.nownodes.io/nft/transfers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get NFT transfers by specified filters.

Parameters

addressstringquery

Address of NFT owner. Must be sent in hex, base64 and base64url forms.

item_addressstringquery

NFT item address. Must be sent in hex, base64 and base64url forms.

collection_addressstringquery

NFT collection address. Must be sent in hex, base64 and base64url forms.

directionstringinoutbothbothquery

Direction transactions by lt.

start_utimeintegerquery

Query transactions with generation UTC timestamp after given timestamp.

end_utimeintegerquery

Query transactions with generation UTC timestamp before given timestamp

start_ltintegerquery

Query transactions with lt >= start_lt

end_ltintegerquery

Query transactions with lt <= end_lt

limitinteger[1, 256]128query

Limit number of queried rows. Use with offset to batch read.

offsetinteger>= 00query

Skip first N rows. Use with limit to batch read.

sortstringascdescdescquery

Sort transactions by lt.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Nft Transfers

curl -X GET 'https://ton-index.nownodes.io/nft/transfers'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton-index.nownodes.io/nft/transfers')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/nft/transfers')
request = Net::HTTP::Get.new(uri)

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

{
  "nft_transfers": [
    {
      "query_id": "string",
      "nft_address": "string",
      "transaction_hash": "string",
      "transaction_lt": "string",
      "transaction_now": 0,
      "old_owner": "string",
      "new_owner": "string",
      "response_destination": "string",
      "custom_payload": "string",
      "forward_amount": "string",
      "forward_payload": "string"
    }
  ]
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Jetton Masters

GET

https://ton-index.nownodes.io/jetton/masters

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get Jetton masters by specified filters.

Parameters

addressstringquery

Jetton Master address. Must be sent in hex, base64 and base64url forms.

admin_addressstringquery

Address of Jetton Masters admin. Must be sent in hex, base64 and base64url forms.

limitinteger[1, 256]128query

Limit number of queried rows. Use with offset to batch read.

offsetinteger>= 00query

Skip first N rows. Use with limit to batch read.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Jetton Masters

curl -X GET 'https://ton-index.nownodes.io/jetton/masters'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton-index.nownodes.io/jetton/masters')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/jetton/masters')
request = Net::HTTP::Get.new(uri)

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

{
  "jetton_masters": [
    {
      "address": "string",
      "total_supply": "string",
      "mintable": true,
      "admin_address": "string",
      "last_transaction_lt": "string",
      "jetton_wallet_code_hash": "string",
      "code_hash": "string",
      "data_hash": "string"
    }
  ]
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Jetton Wallets

GET

https://ton-index.nownodes.io/jetton/wallets

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get Jetton wallets by specified filters.

Parameters

addressstringquery

Jetton wallet address. Must be sent in hex, base64 and base64url forms.

owner_addressstringquery

Address of Jetton wallets owner. Must be sent in hex, base64 and base64url forms.

jetton_addressstringquery

Jetton Master. Must be sent in hex, base64 and base64url forms.

limitinteger[1, 256]128query

Limit number of queried rows. Use with offset to batch read.

offsetinteger>= 00query

Skip first N rows. Use with limit to batch read.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Jetton Wallets

curl -X GET 'https://ton-index.nownodes.io/jetton/wallets'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton-index.nownodes.io/jetton/wallets')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/jetton/wallets')
request = Net::HTTP::Get.new(uri)

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

{
  "jetton_wallets": [
    {
      "address": "string",
      "balance": "string",
      "owner": "string",
      "jetton": "string",
      "last_transaction_lt": "string",
      "code_hash": "string",
      "data_hash": "string"
    }
  ]
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Jetton Transfers

GET

https://ton-index.nownodes.io/jetton/transfers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get Jetton transfers by specified filters.

Parameters

addressstringquery

Account address. Must be sent in hex, base64 and base64url forms.

jetton_walletstringquery

Jetton wallet address. Must be sent in hex, base64 and base64url forms.

jetton_masterstringquery

Jetton master address. Must be sent in hex, base64 and base64url forms.

directionstringinoutbothbothquery

Direction transactions by lt.

start_utimeintegerquery

Query transactions with generation UTC timestamp after given timestamp.

end_utimeintegerquery

Query transactions with generation UTC timestamp before given timestamp

start_ltintegerquery

Query transactions with lt >= start_lt

end_ltintegerquery

Query transactions with lt <= end_lt

limitinteger[1, 256]128query

Limit number of queried rows. Use with offset to batch read.

offsetinteger>= 00query

Skip first N rows. Use with limit to batch read.

sortstringnoneascdescdescquery

Sort transactions by lt.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Jetton Transfers

curl -X GET 'https://ton-index.nownodes.io/jetton/transfers'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton-index.nownodes.io/jetton/transfers')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/jetton/transfers')
request = Net::HTTP::Get.new(uri)

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

{
  "jetton_transfers": [
    {
      "query_id": "string",
      "source": "string",
      "destination": "string",
      "amount": "string",
      "source_wallet": "string",
      "jetton_master": "string",
      "transaction_hash": "string",
      "transaction_lt": "string",
      "transaction_now": 0,
      "response_destination": "string",
      "custom_payload": "string",
      "forward_ton_amount": "string",
      "forward_payload": "string"
    }
  ]
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Jetton Burns

GET

https://ton-index.nownodes.io/jetton/burns

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get Jetton burns by specified filters.

Parameters

addressstringquery

Account address. Must be sent in hex, base64 and base64url forms.

jetton_walletstringquery

Jetton wallet address. Must be sent in hex, base64 and base64url forms.

jetton_masterstringquery

Jetton master address. Must be sent in hex, base64 and base64url forms.

start_utimeintegerquery

Query transactions with generation UTC timestamp after given timestamp.

end_utimeintegerquery

Query transactions with generation UTC timestamp before given timestamp

start_ltintegerquery

Query transactions with lt >= start_lt

end_ltintegerquery

Query transactions with lt <= end_lt

limitinteger[1, 256]128query

Limit number of queried rows. Use with offset to batch read.

offsetinteger>= 00query

Skip first N rows. Use with limit to batch read.

sortstringascdescdescquery

Sort transactions by lt.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Jetton Burns

curl -X GET 'https://ton-index.nownodes.io/jetton/burns'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ton-index.nownodes.io/jetton/burns')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/jetton/burns')
request = Net::HTTP::Get.new(uri)

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

{
  "jetton_burns": [
    {
      "query_id": "string",
      "owner": "string",
      "jetton_master": "string",
      "transaction_hash": "string",
      "transaction_lt": "string",
      "transaction_now": 0,
      "response_destination": "string",
      "custom_payload": "string"
    }
  ]
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Send Message

POST

https://ton-index.nownodes.io/message

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Send external message to TON network.

Body

application/json

Message in boc base64 format.

Message in base64 boc serialized format.

bocstringrequired

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Send Message

curl -X POST 'https://ton-index.nownodes.io/message' \
  -H 'Content-Type: application/json' \
  -d '{
    "boc": [
      "te6ccgECBQEAARUAAkWIAWTtae+KgtbrX26Bep8JSq8lFLfGOoyGR/xwdjfvpvEaHg"
    ]
  }'

const response = await fetch('https://ton-index.nownodes.io/message', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "boc": [
        "te6ccgECBQEAARUAAkWIAWTtae+KgtbrX26Bep8JSq8lFLfGOoyGR/xwdjfvpvEaHg"
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/message')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "boc": [
      "te6ccgECBQEAARUAAkWIAWTtae+KgtbrX26Bep8JSq8lFLfGOoyGR/xwdjfvpvEaHg"
    ]
  }'

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

import requests

payload = {
  "boc": [
    "te6ccgECBQEAARUAAkWIAWTtae+KgtbrX26Bep8JSq8lFLfGOoyGR/xwdjfvpvEaHg"
  ]
}

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

const response = await fetch('https://ton-index.nownodes.io/message', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "boc": [
        "te6ccgECBQEAARUAAkWIAWTtae+KgtbrX26Bep8JSq8lFLfGOoyGR/xwdjfvpvEaHg"
      ]
    }),
});

const data = await response.json();

const endpoint = "https://ton-index.nownodes.io/message";
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": [
      "te6ccgECBQEAARUAAkWIAWTtae+KgtbrX26Bep8JSq8lFLfGOoyGR/xwdjfvpvEaHg"
    ]
  });
console.log(result);

const response = await fetch('https://ton-index.nownodes.io/message', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "boc": [
        "te6ccgECBQEAARUAAkWIAWTtae+KgtbrX26Bep8JSq8lFLfGOoyGR/xwdjfvpvEaHg"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "boc": [
    "te6ccgECBQEAARUAAkWIAWTtae+KgtbrX26Bep8JSq8lFLfGOoyGR/xwdjfvpvEaHg"
  ]
}

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

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/message')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "boc": [
      "te6ccgECBQEAARUAAkWIAWTtae+KgtbrX26Bep8JSq8lFLfGOoyGR/xwdjfvpvEaHg"
    ]
  }'

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

Request Body

{
  "boc": [
    "te6ccgECBQEAARUAAkWIAWTtae+KgtbrX26Bep8JSq8lFLfGOoyGR/xwdjfvpvEaHg"
  ]
}

{
  "message_hash": [
    "383E348617141E35BC25ED9CD0EDEC2A4EAF6413948BF1FB7F865CEFE8C2CD44"
  ]
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Run Get Method

POST

https://ton-index.nownodes.io/runGetMethod

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Run get method of smart contract. Stack supports only num, cell and slice types:

Copied!

[
    {
        "type": "num",
        "value": "0x12a"
    },
    {
        "type": "cell",
        "value": "te6..." // base64 encoded boc with cell
    },
    {
        "type": "slice",
        "value": "te6..." // base64 encoded boc with slice
    }
]

Body

application/json

RunGetMethod request body

any

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Run Get Method

curl -X POST 'https://ton-index.nownodes.io/runGetMethod' \
  -H 'Content-Type: application/json'

const response = await fetch('https://ton-index.nownodes.io/runGetMethod', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/runGetMethod')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'

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

import requests

response = requests.post('https://ton-index.nownodes.io/runGetMethod', headers={'Content-Type': 'application/json'})
data = response.json()

const response = await fetch('https://ton-index.nownodes.io/runGetMethod', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
});

const data = await response.json();

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

const response = await fetch('https://ton-index.nownodes.io/runGetMethod', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
});

const data = await response.json();

import requests

response = requests.post('https://ton-index.nownodes.io/runGetMethod', headers={'Content-Type': 'application/json'})
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/runGetMethod')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'

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

422

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Estimate Fee

POST

https://ton-index.nownodes.io/estimateFee

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Estimate fee for external message.

Body

application/json

EstimateFee request body

addressstringrequired

bodystringrequired

init_codestring

init_datastring

ignore_chksigbooleantrue

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Estimate Fee

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/estimateFee')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "string",
    "body": "string",
    "init_code": "string",
    "init_data": "string",
    "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": "string",
  "init_data": "string",
  "ignore_chksig": True
}

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

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

const data = await response.json();

const endpoint = "https://ton-index.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": "string",
    "init_data": "string",
    "ignore_chksig": true
  });
console.log(result);

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

const data = await response.json();

import requests

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

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

require 'net/http'
require 'json'

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

{
  "source_fees": {
    "in_fwd_fee": 0,
    "storage_fee": 0,
    "gas_fee": 0,
    "fwd_fee": 0
  },
  "destination_fees": [
    {
      "in_fwd_fee": 0,
      "storage_fee": 0,
      "gas_fee": 0,
      "fwd_fee": 0
    }
  ]
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Account Information

GET

https://ton-index.nownodes.io/account

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get smart contract information.

Parameters

addressstringrequiredquery

Account address. Can be sent in raw or user-friendly form.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Account Information

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/account')
request = Net::HTTP::Get.new(uri)

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

{
  "balance": "string",
  "code": "string",
  "data": "string",
  "last_transaction_lt": "string",
  "last_transaction_hash": "string",
  "frozen_hash": "string",
  "status": "uninit"
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Wallet Information

GET

https://ton-index.nownodes.io/wallet

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get wallet smart contract information. The following wallets are supported: v1r1, v1r2, v1r3, v2r1, v2r2, v3r1, v3r2, v4r1, v4r2. In case the account is not a wallet error code 409 is returned.

Parameters

addressstringrequiredquery

Smart contract address. Can be sent in raw or user-friendly form.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Wallet Information

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://ton-index.nownodes.io/wallet')
request = Net::HTTP::Get.new(uri)

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

{
  "balance": "string",
  "wallet_type": "string",
  "seqno": 0,
  "wallet_id": 0,
  "last_transaction_lt": "string",
  "last_transaction_hash": "string",
  "status": "uninit"
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Documentation

How to migrate to NOWNodes

Authentication

TON Index (mainnet)

API V3 Reference (Index)

Authorizations

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response