Hedera

v1.0.0

Base URL

https://hedera.nownodes.io

Authentication

api-keyAuthapiKey

API Key: api-key in header

Node

accounts

List account entities on network

GET

https://hedera.nownodes.io/api/v1/accounts

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of all account entity items on the network.

Parameters

account.balancestringquery

The optional balance value to compare against

account.idEntityIdQueryquery

The ID of the account to return information for

account.publickeystringquery

The account's public key to compare against

balancebooleantruequery

Whether to include balance information or not. If included, token balances are limited to at most 50 per account as outlined in HIP-367. If multiple values are provided the last value will be the only value used.

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescascquery

The order in which items are listed

Response

200OK

400Bad Request

Invalid parameter

List account entities on network

curl -X GET 'https://hedera.nownodes.io/api/v1/accounts'

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts')
request = Net::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://hedera.nownodes.io/api/v1/accounts')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/accounts')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts')
request = Net::HTTP::Get.new(uri)

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

{
  "accounts": [
    {
      "account": "0.0.8",
      "alias": "HIQQEXWKW53RKN4W6XXC4Q232SYNZ3SZANVZZSUME5B5PRGXL663UAQA",
      "auto_renew_period": null,
      "balance": {
        "timestamp": "0.000002345",
        "balance": 80,
        "tokens": [
          {
            "token_id": "0.0.200001",
            "balance": 8
          }
        ]
      },
      "created_timestamp": "1562591528.000123456",
      "decline_reward": false,
      "deleted": false,
      "ethereum_nonce": 10,
      "evm_address": "0xac384c53f03855fa1b3616052f8ba32c6c2a2fec",
      "expiry_timestamp": null,
      "key": null,
      "max_automatic_token_associations": 200,
      "memo": "entity memo",
      "pending_reward": 100,
      "receiver_sig_required": false,
      "staked_account_id": null,
      "staked_node_id": 3,
      "stake_period_start": "172800000.000000000"
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

Get account by alias, id, or evm address

GET

https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Return the account transactions and balance information given an account alias, an account id, or an evm address. The information will be limited to at most 1000 token balances for the account as outlined in HIP-367. When the timestamp parameter is supplied, we will return transactions and account state for the relevant timestamp query. Balance information will be accurate to within 15 minutes of the provided timestamp query. Historical ethereum nonce information is currently not available and may not be the exact value at a provided timestamp.

Parameters

idOrAliasOrEvmAddressstringrequiredpath

Account alias or account id or evm address

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescdescquery

The order in which items are listed

timestampArray<string>query

The consensus timestamp as a Unix timestamp in seconds.nanoseconds format with an optional comparison operator. See unixtimestamp.com for a simple way to convert a date to the 'seconds' part of the Unix time.

transactiontypeTransactionTypesATOMICBATCHCONSENSUSCREATETOPICCONSENSUSDELETETOPICCONSENSUSSUBMITMESSAGECONSENSUSUPDATETOPICCONTRACTCALLCONTRACTCREATEINSTANCECONTRACTDELETEINSTANCECONTRACTUPDATEINSTANCECRYPTOADDLIVEHASHCRYPTOAPPROVEALLOWANCECRYPTOCREATEACCOUNTCRYPTODELETECRYPTODELETEALLOWANCECRYPTODELETELIVEHASHCRYPTOTRANSFERCRYPTOUPDATEACCOUNTETHEREUMTRANSACTIONFILEAPPENDFILECREATEFILEDELETEFILEUPDATEFREEZENODENODECREATENODEDELETENODESTAKEUPDATENODEUPDATESCHEDULECREATESCHEDULEDELETESCHEDULESIGNSYSTEMDELETESYSTEMUNDELETETOKENAIRDROPTOKENASSOCIATETOKENBURNTOKENCANCELAIRDROPTOKENCLAIMAIRDROPTOKENCREATIONTOKENDELETIONTOKENDISSOCIATETOKENFEESCHEDULEUPDATETOKENFREEZETOKENGRANTKYCTOKENMINTTOKENPAUSETOKENREJECTTOKENREVOKEKYCTOKENUNFREEZETOKENUNPAUSETOKENUPDATETOKENUPDATENFTSTOKENWIPEUNCHECKEDSUBMITUNKNOWNUTILPRNGquery

transactionsbooleantruequery

If provided and set to false transactions will not be included in the response

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get account by alias, id, or evm address

curl -X GET 'https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}'

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}')
request = Net::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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}";
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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}')
request = Net::HTTP::Get.new(uri)

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

{
  "account": "0.0.8",
  "alias": "HIQQEXWKW53RKN4W6XXC4Q232SYNZ3SZANVZZSUME5B5PRGXL663UAQA",
  "auto_renew_period": null,
  "balance": {
    "timestamp": "0.000002345",
    "balance": 80,
    "tokens": [
      {
        "token_id": "0.0.200001",
        "balance": 8
      }
    ]
  },
  "created_timestamp": "1562591528.000123456",
  "decline_reward": false,
  "deleted": false,
  "ethereum_nonce": 10,
  "evm_address": "0xac384c53f03855fa1b3616052f8ba32c6c2a2fec",
  "expiry_timestamp": null,
  "key": null,
  "max_automatic_token_associations": 200,
  "memo": "entity memo",
  "pending_reward": 100,
  "receiver_sig_required": false,
  "staked_account_id": null,
  "staked_node_id": 3,
  "stake_period_start": "172800000.000000000",
  "transactions": [
    {
      "batch_key": "0xae8bebf1c9fa0f309356e48057f6047af7cde63037d0509d16ddc3b20e085158bfdf14d15345c1b18b199b72fed4dead",
      "bytes": null,
      "charged_tx_fee": 7,
      "consensus_timestamp": "1234567890.000000007",
      "entity_id": "0.0.2281979",
      "max_custom_fees": [
        {
          "account_id": "0.0.8",
          "amount": 1000,
          "denominating_token_id": "0.0.2000"
        },
        {
          "account_id": "0.0.8",
          "amount": 1500,
          "denominating_token_id": null
        }
      ],
      "max_fee": 33,
      "memo_base64": null,
      "name": "CRYPTOTRANSFER",
      "nft_transfers": [
        {
          "is_approval": true,
          "receiver_account_id": "0.0.121",
          "sender_account_id": "0.0.122",
          "serial_number": 1,
          "token_id": "0.0.123"
        },
        {
          "is_approval": true,
          "receiver_account_id": "0.0.321",
          "sender_account_id": "0.0.422",
          "serial_number": 2,
          "token_id": "0.0.123"
        }
      ],
      "node": "0.0.3",
      "nonce": 0,
      "parent_consensus_timestamp": "1234567890.000000007",
      "result": "SUCCESS",
      "scheduled": false,
      "staking_reward_transfers": [
        {
          "account": 3,
          "amount": 150
        },
        {
          "account": 9,
          "amount": 200
        }
      ],
      "transaction_hash": "vigzKe2J7fv4ktHBbNTSzQmKq7Lzdq1/lJMmHT+a2KgvdhAuadlvS4eKeqKjIRmW",
      "transaction_id": "0.0.8-1234567890-000000006",
      "token_transfers": [
        {
          "token_id": "0.0.90000",
          "account": "0.0.9",
          "amount": 1200,
          "is_approval": false
        },
        {
          "token_id": "0.0.90000",
          "account": "0.0.8",
          "amount": -1200,
          "is_approval": false
        }
      ],
      "transfers": [
        {
          "account": "0.0.3",
          "amount": 2,
          "is_approval": false
        },
        {
          "account": "0.0.8",
          "amount": -3,
          "is_approval": false
        },
        {
          "account": "0.0.98",
          "amount": 1,
          "is_approval": false
        },
        {
          "account": "0.0.800",
          "amount": 150,
          "is_approval": false
        },
        {
          "account": "0.0.800",
          "amount": 200,
          "is_approval": false
        }
      ],
      "valid_duration_seconds": 11,
      "valid_start_timestamp": "1234567890.000000006"
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

List hooks for an account

GET

https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/hooks

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of hooks associated with a given account ID, alias, or EVM address.

Parameters

idOrAliasOrEvmAddressstringrequiredpath

Account alias or account id or evm address

hook.idinteger<int64>[1, 9223372036854776000]query

The ID of the hook

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescdescquery

The order in which items are listed

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

List hooks for an account

curl -X GET 'https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/hooks'

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/hooks', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/hooks')
request = Net::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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/hooks')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/hooks', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/hooks";
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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/hooks', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/hooks')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/hooks')
request = Net::HTTP::Get.new(uri)

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

{
  "hooks": [
    {
      "admin_key": {
        "_type": "ProtobufEncoded",
        "key": "15706b229b3ba33d4a5a41ff54ce1cfe0a3d308672a33ff382f81583e02bd743"
      },
      "deleted": false,
      "extension_point": "ACCOUNT_ALLOWANCE_HOOK",
      "hook_id": 1,
      "timestamp_range": {},
      "type": "LAMBDA"
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

Get nfts for an account info

GET

https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/nfts

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information for all non-fungible tokens for an account.

Ordering

When considering NFTs, their order is governed by a combination of their numerical token.Id and serialnumber values, with token.id being the parent column. A serialnumbers value governs its order within the given token.id

In that regard, if a user acquired a set of NFTs in the order (2-2, 2-4 1-5, 1-1, 1-3, 3-3, 3-4), the following layouts illustrate the ordering expectations for ownership listing

All NFTs in ASC order: 1-1, 1-3, 1-5, 2-2, 2-4, 3-3, 3-4
All NFTs in DESC order: 3-4, 3-3, 2-4, 2-2, 1-5, 1-3, 1-1
NFTs above 1-1 in ASC order: 1-3, 1-5, 2-2, 2-4, 3-3, 3-4
NFTs below 3-3 in ASC order: 1-1, 1-3, 1-5, 2-2, 2-4
NFTs between 1-3 and 3-3 inclusive in DESC order: 3-4, 3-3, 2-4, 2-2, 1-5, 1-3

Note: The default order for this API is currently DESC

Filtering

When filtering there are some restrictions enforced to ensure correctness and scalability.

The table below defines the restrictions and support for the NFT ownership endpoint

Query Param	Comparison Operator	Support	Description	Example
token.id	eq	Y	Single occurrence only.	?token.id=X
	ne	N
	lt(e)	Y	Single occurrence only.	?token.id=lte:X
	gt(e)	Y	Single occurrence only.	?token.id=gte:X
serialnumber	eq	Y	Single occurrence only. Requires the presence of a token.id query	?serialnumber=Y
	ne	N
	lt(e)	Y	Single occurrence only. Requires the presence of an lte or eq token.id query	?token.id=lte:X&serialnumber=lt:Y
	gt(e)	Y	Single occurrence only. Requires the presence of an gte or eq token.id query	?token.id=gte:X&serialnumber=gt:Y
spender.id	eq	Y		?spender.id=Z
	ne	N
	lt(e)	Y		?spender.id=lt:Z
	gt(e)	Y		?spender.id=gt:Z

Note: When searching across a range for individual NFTs a serialnumber with an additional token.id query filter must be provided. Both filters must be a single occurrence of gt(e) or lt(e) which provide a lower and or upper boundary for search.

Parameters

idOrAliasOrEvmAddressstringrequiredpath

Account alias or account id or evm address

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescdescquery

The order in which items are listed

serialnumberstringquery

The nft serial number (64 bit type). Requires a tokenId value also be populated.

spender.idEntityIdQueryquery

The ID of the spender to return information for

token.idEntityIdQueryquery

The ID of the token to return information for

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get nfts for an account info

curl -X GET 'https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/nfts'

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/nfts', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/nfts')
request = Net::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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/nfts')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/nfts', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/nfts";
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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/nfts', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/nfts')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/nfts')
request = Net::HTTP::Get.new(uri)

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

{
  "nfts": [
    {
      "account_id": "0.1.2",
      "created_timestamp": "1234567890.000000001",
      "delegating_spender": "0.0.400",
      "deleted": false,
      "metadata": "VGhpcyBpcyBhIHRlc3QgTkZU",
      "modified_timestamp": "1610682445.003266001",
      "serial_number": 124,
      "spender_id": "0.0.500",
      "token_id": "0.0.222"
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

Get past staking reward payouts for an account

GET

https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/rewards

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information for all past staking reward payouts for an account.

Parameters

idOrAliasOrEvmAddressstringrequiredpath

Account alias or account id or evm address

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescdescquery

The order in which items are listed

timestampArray<string>query

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get past staking reward payouts for an account

curl -X GET 'https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/rewards'

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/rewards', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/rewards')
request = Net::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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/rewards')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/rewards', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/rewards";
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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/rewards', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/rewards')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/rewards')
request = Net::HTTP::Get.new(uri)

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

{
  "rewards": [
    {
      "account_id": "0.0.1000",
      "amount": 10,
      "timestamp": "1234567890.000000001"
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

Get token relationships info for an account

GET

https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/tokens

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information for all token relationships for an account.

Parameters

idOrAliasOrEvmAddressstringrequiredpath

Account alias or account id or evm address

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescascquery

The order in which items are listed

token.idEntityIdQueryquery

The ID of the token to return information for

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get token relationships info for an account

curl -X GET 'https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/tokens'

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/tokens', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/tokens')
request = Net::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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/tokens')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/tokens', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/tokens";
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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/tokens', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/tokens')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/tokens')
request = Net::HTTP::Get.new(uri)

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

{
  "tokens": [
    {
      "automatic_association": true,
      "balance": 5,
      "created_timestamp": "123456789.000000001",
      "decimals": 3,
      "freeze_status": "UNFROZEN",
      "kyc_status": "GRANTED",
      "token_id": "0.0.27335"
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

Get crypto allowances for an account info

GET

https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/crypto

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information for all crypto allowances for an account.

Parameters

idOrAliasOrEvmAddressstringrequiredpath

Account alias or account id or evm address

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescdescquery

The order in which items are listed

spender.idEntityIdQueryquery

The ID of the spender to return information for

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get crypto allowances for an account info

curl -X GET 'https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/crypto'

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/crypto', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/crypto')
request = Net::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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/crypto')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/crypto', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/crypto";
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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/crypto', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/crypto')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/crypto')
request = Net::HTTP::Get.new(uri)

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

{
  "allowances": [
    {
      "amount": 0,
      "amount_granted": 0,
      "owner": "0.0.2",
      "spender": "0.0.2",
      "timestamp": {}
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

Get fungible token allowances for an account

GET

https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/tokens

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information for fungible token allowances for an account.

Ordering

The order is governed by a combination of the spender id and the token id values, with spender id being the parent column. The token id value governs its order within the given spender id.

Note: The default order for this API is currently ASC

Filtering

When filtering there are some restrictions enforced to ensure correctness and scalability.

The table below defines the restrictions and support for the endpoint

Query Param	Comparison Operator	Support	Description	Example
spender.id	eq	Y	Single occurrence only.	?spender.id=X
	ne	N
	lt(e)	Y	Single occurrence only.	?spender.id=lte:X
	gt(e)	Y	Single occurrence only.	?spender.id=gte:X
token.id	eq	Y	Single occurrence only. Requires the presence of a spender.id query	?token.id=lt:Y
	ne	N
	lt(e)	Y	Single occurrence only. Requires the presence of an lte or eq spender.id query	?spender.id=lte:X&token.id=lt:Y
	gt(e)	Y	Single occurrence only. Requires the presence of an gte or eq spender.id query	?spender.id=gte:X&token.id=gt:Y

Both filters must be a single occurrence of gt(e) or lt(e) which provide a lower and or upper boundary for search.

Parameters

idOrAliasOrEvmAddressstringrequiredpath

Account alias or account id or evm address

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescascquery

The order in which items are listed

spender.idEntityIdQueryquery

The ID of the spender to return information for

token.idEntityIdQueryquery

The ID of the token to return information for

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get fungible token allowances for an account

curl -X GET 'https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/tokens'

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/tokens', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/tokens')
request = Net::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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/tokens')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/tokens', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/tokens";
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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/tokens', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/tokens')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/tokens')
request = Net::HTTP::Get.new(uri)

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

{
  "allowances": [
    {
      "amount": 75,
      "amount_granted": 100,
      "owner": "0.0.2",
      "spender": "0.0.2",
      "timestamp": {},
      "token_id": "0.0.2"
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

Get non fungible token allowances for an account

GET

https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/nfts

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an account's non-fungible token allowances.

Ordering

The order is governed by a combination of the account ID and the token ID values, with account ID being the parent column. The token ID value governs its order within the given account ID.

Note: The default order for this API is currently ascending. The account ID can be the owner or the spender ID depending upon the owner flag.

Filtering

When filtering there are some restrictions enforced to ensure correctness and scalability.

The table below defines the restrictions and support for the endpoint

Query Param	Comparison Operator	Support	Description	Example
account.id	eq	Y	Single occurrence only.	?account.id=X
	ne	N
	lt(e)	Y	Single occurrence only.	?account.id=lte:X
	gt(e)	Y	Single occurrence only.	?account.id=gte:X
token.id	eq	Y	Single occurrence only. Requires the presence of an account.id parameter	?account.id=X&token.id=eq:Y
	ne	N
	lt(e)	Y	Single occurrence only. Requires the presence of an lte or eq account.id parameter	?account.id=lte:X&token.id=lt:Y
	gt(e)	Y	Single occurrence only. Requires the presence of an gte or eq account.id parameter	?account.id=gte:X&token.id=gt:Y

Both filters must be a single occurrence of gt(e) or lt(e) which provide a lower and or upper boundary for search.

Parameters

idOrAliasOrEvmAddressstringrequiredpath

Account alias or account id or evm address

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescascquery

The order in which items are listed

account.idEntityIdQueryquery

The ID of the account to return information for

token.idEntityIdQueryquery

The ID of the token to return information for

ownerbooleantruequery

When the owner value is true or omitted, the accountId path parameter will specify the ID of the owner, and the API will retrieve the allowances that the owner has granted to different spenders. Conversely, when the owner value is false, the accountId path parameter will indicate the ID of the spender who has an allowance, and the API will instead provide the allowances granted to the spender by different owners of those tokens.

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get non fungible token allowances for an account

curl -X GET 'https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/nfts'

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/nfts', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/nfts')
request = Net::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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/nfts')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/nfts', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/nfts";
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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/nfts', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/nfts')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/allowances/nfts')
request = Net::HTTP::Get.new(uri)

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

{
  "allowances": [
    {
      "approved_for_all": false,
      "owner": "0.0.11",
      "payer_account_id": "0.0.10",
      "spender": "0.0.15",
      "timestamp": {
        "from": "1651560386.060890949",
        "to": "1651560386.661997287"
      },
      "token_id": "0.0.99"
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

airdrops

Get outstanding token airdrops sent by an account

GET

https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/outstanding

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns outstanding token airdrops that have been sent by an account.

Parameters

idOrAliasOrEvmAddressstringrequiredpath

Account alias or account id or evm address

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescascquery

The order in which items are listed

receiver.idEntityIdQueryquery

The ID of the receiver to return information for

serialnumberstringquery

The nft serial number (64 bit type). Requires a tokenId value also be populated.

token.idEntityIdQueryquery

The ID of the token to return information for

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get outstanding token airdrops sent by an account

curl -X GET 'https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/outstanding'

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/outstanding', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/outstanding')
request = Net::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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/outstanding')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/outstanding', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/outstanding";
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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/outstanding', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/outstanding')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/outstanding')
request = Net::HTTP::Get.new(uri)

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

{
  "airdrops": [
    {
      "amount": 10,
      "receiver_id": "0.0.15",
      "sender_id": "0.0.10",
      "serial_number": null,
      "timestamp": {
        "from": "1651560386.060890949",
        "to": "1651560386.661997287"
      },
      "token_id": "0.0.99"
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

Get pending token airdrops received by an account

GET

https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/pending

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns pending token airdrops that have been received by an account.

Parameters

idOrAliasOrEvmAddressstringrequiredpath

Account alias or account id or evm address

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescascquery

The order in which items are listed

sender.idEntityIdQueryquery

The ID of the sender to return information for

serialnumberstringquery

The nft serial number (64 bit type). Requires a tokenId value also be populated.

token.idEntityIdQueryquery

The ID of the token to return information for

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get pending token airdrops received by an account

curl -X GET 'https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/pending'

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/pending', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/pending')
request = Net::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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/pending')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/pending', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/pending";
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://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/pending', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/pending')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/accounts/{idOrAliasOrEvmAddress}/airdrops/pending')
request = Net::HTTP::Get.new(uri)

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

{
  "airdrops": [
    {
      "amount": 10,
      "receiver_id": "0.0.15",
      "sender_id": "0.0.10",
      "serial_number": null,
      "timestamp": {
        "from": "1651560386.060890949",
        "to": "1651560386.661997287"
      },
      "token_id": "0.0.99"
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

balances

List account balances

GET

https://hedera.nownodes.io/api/v1/balances

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of account and token balances on the network. The latest balance information is returned when there is no timestamp query parameter, otherwise, the information is retrieved from snapshots with 15-minute granularity. This information is limited to at most 50 token balances per account as outlined in HIP-367. As such, it's not recommended for general use and we instead recommend using either /api/v1/accounts/{id}/tokens or /api/v1/tokens/{id}/balances to obtain the current token balance information and /api/v1/accounts/{id} to return the current account balance.

Parameters

account.idstringquery

Account id or account alias with no shard realm or evm address with no shard realm

account.balancestringquery

The optional balance value to compare against

account.publickeystringquery

The account's public key to compare against

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescdescquery

The order in which items are listed

timestampArray<string>query

Response

200OK

400Bad Request

Invalid parameter

List account balances

curl -X GET 'https://hedera.nownodes.io/api/v1/balances'

const response = await fetch('https://hedera.nownodes.io/api/v1/balances', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/balances')
request = Net::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://hedera.nownodes.io/api/v1/balances')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/balances', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/balances')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/balances')
request = Net::HTTP::Get.new(uri)

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

{
  "timestamp": "1586567700.453054000",
  "balances": [
    {
      "account": "0.15.10",
      "balance": 80,
      "tokens": [
        {
          "token_id": "0.0.200001",
          "balance": 8
        }
      ]
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

blocks

List blocks

GET

https://hedera.nownodes.io/api/v1/blocks

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of blocks on the network.

Parameters

block.numberstringquery

The block's number

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescdescquery

The order in which items are listed

timestampArray<string>query

Response

200OK

400Bad Request

Invalid parameter

List blocks

curl -X GET 'https://hedera.nownodes.io/api/v1/blocks'

const response = await fetch('https://hedera.nownodes.io/api/v1/blocks', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/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://hedera.nownodes.io/api/v1/blocks')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/blocks', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/blocks')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/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": [
    {
      "count": 3,
      "gas_used": 300000,
      "hapi_version": "0.11.0",
      "hash": "0x3c08bbbee74d287b1dcd3f0ca6d1d2cb92c90883c4acf9747de9f3f3162ad25b999fc7e86699f60f2a3fb3ed9a646c6b",
      "logs_bloom": "0x00000020002000001000000000000000000000000000000000000000000010000000000004000000000000000000000000108000000000000000000080000000000004000000000000000000000000880000000000000000000101000000000000000000000000000000000000008000000000000400000080000000000001000000000000000000000000000000000000000000002000000000100000100000200000040000100000001000000000000000000000000000000001001000004000000000000000000001000000000000000000100000000000100000000000000000000000000000000000000000000000080000100800000000000000120080",
      "name": "2022-05-03T06_46_26.060890949Z.rcd",
      "number": 77,
      "previous_hash": "0xf7d6481f659c866c35391ee230c374f163642ebf13a5e604e04a95a9ca48a298dc2dfa10f51bcbaab8ae23bc6d662a0b",
      "size": 8192,
      "timestamp": {
        "from": "1651560386.060890949",
        "to": "1651560386.661997287"
      }
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

Get block by hash or number

GET

https://hedera.nownodes.io/api/v1/blocks/{hashOrNumber}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the block information by given hash or number.

Parameters

hashOrNumberstringrequiredpath

Accepts both eth and hedera hash format or block number

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get block by hash or number

curl -X GET 'https://hedera.nownodes.io/api/v1/blocks/{hashOrNumber}'

const response = await fetch('https://hedera.nownodes.io/api/v1/blocks/{hashOrNumber}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/blocks/{hashOrNumber}')
request = Net::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://hedera.nownodes.io/api/v1/blocks/{hashOrNumber}')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/blocks/{hashOrNumber}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/blocks/{hashOrNumber}";
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://hedera.nownodes.io/api/v1/blocks/{hashOrNumber}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/blocks/{hashOrNumber}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/blocks/{hashOrNumber}')
request = Net::HTTP::Get.new(uri)

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

{
  "count": 3,
  "gas_used": 300000,
  "hapi_version": "0.11.0",
  "hash": "0x3c08bbbee74d287b1dcd3f0ca6d1d2cb92c90883c4acf9747de9f3f3162ad25b999fc7e86699f60f2a3fb3ed9a646c6b",
  "logs_bloom": "0x00000020002000001000000000000000000000000000000000000000000010000000000004000000000000000000000000108000000000000000000080000000000004000000000000000000000000880000000000000000000101000000000000000000000000000000000000008000000000000400000080000000000001000000000000000000000000000000000000000000002000000000100000100000200000040000100000001000000000000000000000000000000001001000004000000000000000000001000000000000000000100000000000100000000000000000000000000000000000000000000000080000100800000000000000120080",
  "name": "2022-05-03T06_46_26.060890949Z.rcd",
  "number": 77,
  "previous_hash": "0xf7d6481f659c866c35391ee230c374f163642ebf13a5e604e04a95a9ca48a298dc2dfa10f51bcbaab8ae23bc6d662a0b",
  "size": 8192,
  "timestamp": {
    "from": "1651560386.060890949",
    "to": "1651560386.661997287"
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

contracts

Invoke a smart contract

POST

https://hedera.nownodes.io/api/v1/contracts/call

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a result from EVM execution such as cost-free execution of read-only smart contract queries, gas estimation, and transient simulation of read-write operations. If the estimate field is set to true gas estimation is executed. However, gas estimation only supports the latest block. When estimate is false, it can process calls against the earliest block and specific historical blocks when a hexadecimal or decimal block number is provided in the block field for eth_call operations. Link to Supported/Unsupported Operations Table The operations types which are not currently supported should return 501 error status.

Body

application/json

blockstring | null

Hexadecimal block number or the string "latest", "pending", "earliest". Defaults to "latest".

datastring<binary> | null

Hexadecimal method signature and encoded parameters. Up to 131072 bytes as at most 262146 hexadecimal digits including optional leading 0x.

estimateboolean | null

Whether gas estimation is called. Defaults to false.

fromstring<binary> | null

The 20-byte hexadecimal EVM address the transaction is sent from.

gasinteger<int64> | null>= 0

Gas provided for the transaction execution. Defaults to 15000000.

gasPriceinteger<int64> | null>= 0

Gas price used for each paid gas.

tostring<binary>required

The 20-byte hexadecimal EVM address the transaction is directed to.

valueinteger<int64> | null>= 0

Value sent with this transaction. Defaults to 0.

Response

200OK

400Bad Request

Validation error

404Not Found

Not found error

415Unsupported Media Type

Unsupported media type error

429Too Many Requests

Too many requests

500Internal Server Error

Generic error

501Not Implemented

Not implemented error

Invoke a smart contract

curl -X POST 'https://hedera.nownodes.io/api/v1/contracts/call' \
  -H 'Content-Type: application/json' \
  -d '{
    "block": "latest",
    "data": "0x47f1aae7",
    "estimate": true,
    "from": "00000000000000000000000000000000000004e2",
    "gas": 15000000,
    "gasPrice": 100000000,
    "to": "0xd9d0c5c0ff85758bdf05a7636f8036d4d065f5b6",
    "value": 0
  }'

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/call', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "block": "latest",
      "data": "0x47f1aae7",
      "estimate": true,
      "from": "00000000000000000000000000000000000004e2",
      "gas": 15000000,
      "gasPrice": 100000000,
      "to": "0xd9d0c5c0ff85758bdf05a7636f8036d4d065f5b6",
      "value": 0
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/call')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "block": "latest",
    "data": "0x47f1aae7",
    "estimate": true,
    "from": "00000000000000000000000000000000000004e2",
    "gas": 15000000,
    "gasPrice": 100000000,
    "to": "0xd9d0c5c0ff85758bdf05a7636f8036d4d065f5b6",
    "value": 0
  }'

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

import requests

payload = {
  "block": "latest",
  "data": "0x47f1aae7",
  "estimate": True,
  "from": "00000000000000000000000000000000000004e2",
  "gas": 15000000,
  "gasPrice": 100000000,
  "to": "0xd9d0c5c0ff85758bdf05a7636f8036d4d065f5b6",
  "value": 0
}

response = requests.post('https://hedera.nownodes.io/api/v1/contracts/call', json=payload)
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/call', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "block": "latest",
      "data": "0x47f1aae7",
      "estimate": true,
      "from": "00000000000000000000000000000000000004e2",
      "gas": 15000000,
      "gasPrice": 100000000,
      "to": "0xd9d0c5c0ff85758bdf05a7636f8036d4d065f5b6",
      "value": 0
    }),
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/contracts/call";
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({
    "block": "latest",
    "data": "0x47f1aae7",
    "estimate": true,
    "from": "00000000000000000000000000000000000004e2",
    "gas": 15000000,
    "gasPrice": 100000000,
    "to": "0xd9d0c5c0ff85758bdf05a7636f8036d4d065f5b6",
    "value": 0
  });
console.log(result);

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/call', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "block": "latest",
      "data": "0x47f1aae7",
      "estimate": true,
      "from": "00000000000000000000000000000000000004e2",
      "gas": 15000000,
      "gasPrice": 100000000,
      "to": "0xd9d0c5c0ff85758bdf05a7636f8036d4d065f5b6",
      "value": 0
    }),
});

const data = await response.json();

import requests

payload = {
  "block": "latest",
  "data": "0x47f1aae7",
  "estimate": True,
  "from": "00000000000000000000000000000000000004e2",
  "gas": 15000000,
  "gasPrice": 100000000,
  "to": "0xd9d0c5c0ff85758bdf05a7636f8036d4d065f5b6",
  "value": 0
}

response = requests.post('https://hedera.nownodes.io/api/v1/contracts/call', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/call')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "block": "latest",
    "data": "0x47f1aae7",
    "estimate": true,
    "from": "00000000000000000000000000000000000004e2",
    "gas": 15000000,
    "gasPrice": 100000000,
    "to": "0xd9d0c5c0ff85758bdf05a7636f8036d4d065f5b6",
    "value": 0
  }'

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

Request Body

{
  "block": "latest",
  "data": "0x47f1aae7",
  "estimate": true,
  "from": "00000000000000000000000000000000000004e2",
  "gas": 15000000,
  "gasPrice": 100000000,
  "to": "0xd9d0c5c0ff85758bdf05a7636f8036d4d065f5b6",
  "value": 0
}

{
  "result": "0x0000000000006d8d"
}

{
  "_status": {
    "messages": [
      {
        "data": "0x3000",
        "detail": "Generic detailed error message",
        "message": "Generic error message"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "data": "0x3000",
        "detail": "Generic detailed error message",
        "message": "Generic error message"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "data": "0x3000",
        "detail": "Generic detailed error message",
        "message": "Generic error message"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "data": "0x3000",
        "detail": "Generic detailed error message",
        "message": "Generic error message"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "data": "0x3000",
        "detail": "Generic detailed error message",
        "message": "Generic error message"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "data": "0x3000",
        "detail": "Generic detailed error message",
        "message": "Generic error message"
      }
    ]
  }
}

List contract entities on network

GET

https://hedera.nownodes.io/api/v1/contracts

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of all contract entity items on the network.

Parameters

contract.idstringquery

The ID of the smart contract

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescdescquery

The order in which items are listed

Response

200OK

400Bad Request

Invalid parameter

List contract entities on network

curl -X GET 'https://hedera.nownodes.io/api/v1/contracts'

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts')
request = Net::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://hedera.nownodes.io/api/v1/contracts')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/contracts')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts')
request = Net::HTTP::Get.new(uri)

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

{
  "contracts": [
    {
      "admin_key": {
        "_type": "ProtobufEncoded",
        "key": "15706b229b3ba33d4a5a41ff54ce1cfe0a3d308672a33ff382f81583e02bd743"
      },
      "auto_renew_account": "0.0.2",
      "auto_renew_period": 7776000,
      "contract_id": "0.0.2",
      "created_timestamp": "1586567700.453054000",
      "deleted": false,
      "evm_address": "0000000000000000000000000000000000001f41",
      "expiration_timestamp": "1586567700.453054000",
      "file_id": "0.0.2",
      "max_automatic_token_associations": 0,
      "memo": "contract memo",
      "nonce": 1,
      "obtainer_id": "0.0.2",
      "permanent_removal": true,
      "proxy_account_id": "0.0.2",
      "timestamp": {}
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

Get contract by id

GET

https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Return the contract information given an id

Parameters

contractIdOrAddressstringrequiredpath

The ID or hex encoded EVM address (with or without 0x prefix) associated with this contract.

timestampArray<string>query

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get contract by id

curl -X GET 'https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}'

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}')
request = Net::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://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}";
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://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}')
request = Net::HTTP::Get.new(uri)

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

{
  "admin_key": {
    "_type": "ProtobufEncoded",
    "key": "15706b229b3ba33d4a5a41ff54ce1cfe0a3d308672a33ff382f81583e02bd743"
  },
  "auto_renew_account": "0.0.2",
  "auto_renew_period": 7776000,
  "contract_id": "0.0.2",
  "created_timestamp": "1586567700.453054000",
  "deleted": false,
  "evm_address": "0000000000000000000000000000000000001f41",
  "expiration_timestamp": "1586567700.453054000",
  "file_id": "0.0.2",
  "max_automatic_token_associations": 0,
  "memo": "contract memo",
  "nonce": 1,
  "obtainer_id": "0.0.2",
  "permanent_removal": true,
  "proxy_account_id": "0.0.2",
  "timestamp": {},
  "bytecode": "0x01021a1fdc9b",
  "runtime_bytecode": "0x0302fa1ad39c"
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

List contract results from a contract on the network

GET

https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of all ContractResults for a contract's function executions.

Parameters

contractIdOrAddressstringrequiredpath

The ID or hex encoded EVM address (with or without 0x prefix) associated with this contract.

block.hashstringquery

The block's hash. If multiple values are provided the last value will be the only value used.

block.numberstringquery

The block's number

fromstringquery

Account ID or EVM address executing the contract

internalbooleanfalsequery

Whether to include child transactions or not

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescdescquery

The order in which items are listed

timestampArray<string>query

transaction.indexinteger<int32>>= 0query

The transaction index in the block

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

List contract results from a contract on the network

curl -X GET 'https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results'

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results')
request = Net::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://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results";
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://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results')
request = Net::HTTP::Get.new(uri)

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

{
  "results": [
    {
      "access_list": "0xabcd",
      "address": "0x25fe26adc577cc89172e6156c9e24f7b9751b762",
      "amount": 10,
      "block_gas_used": 2000,
      "block_hash": "0x6ceecd8bb224da491",
      "block_number": 10,
      "call_result": "0x2b048531b38d2882e86044bc972e940ee0a01938",
      "chain_id": "0x0127",
      "contract_id": "0.0.2",
      "created_contract_ids": [
        "0.0.2"
      ],
      "error_message": "Out of gas",
      "failed_initcode": "0x856739",
      "from": "0x0000000000000000000000000000000000001f41",
      "function_parameters": "0xbb9f02dc6f0e3289f57a1f33b71c73aa8548ab8b",
      "gas_consumed": 35000,
      "gas_limit": 100000,
      "gas_price": "0x4a817c800",
      "gas_used": 80000,
      "hash": "0xfebbaa29c513d124a6377246ea3506ad917d740c21a88f61a1c55ba338fc2bb1",
      "max_fee_per_gas": "0x5",
      "max_priority_fee_per_gas": "0x100",
      "nonce": 1,
      "r": "0xd693b532a80fed6392b428604171fb32fdbf953728a3a7ecc7d4062b1652c043",
      "result": "SUCCESS",
      "s": "0x24e9c602ac800b983b035700a14b23f78a253ab762deab5dc27e3555a750b355",
      "status": 1,
      "timestamp": "1586567700.453054000",
      "to": "0x0000000000000000000000000000000000001f41",
      "transaction_index": 1,
      "type": 2,
      "v": 1
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

The contract state from a contract on the network

GET

https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/state

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of all contract's slots. If no timestamp is provided, returns the current state.

Parameters

contractIdOrAddressstringrequiredpath

The ID or hex encoded EVM address (with or without 0x prefix) associated with this contract.

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescascquery

The order in which items are listed

slotstringquery

The slot's number

timestampArray<string>query

The consensus timestamp of the contract state as a Unix timestamp in seconds.nanoseconds format with an optional comparison operator. See unixtimestamp.com for a simple way to convert a date to the 'seconds' part of the Unix time.

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

The contract state from a contract on the network

curl -X GET 'https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/state'

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/state', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/state')
request = Net::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://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/state')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/state', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/state";
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://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/state', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/state')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/state')
request = Net::HTTP::Get.new(uri)

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

{
  "state": [
    {
      "address": "0000000000000000000000000000000000001f41",
      "contract_id": "0.0.2",
      "timestamp": "1586567700.453054000",
      "slot": "0x00000000000000000000000000000000000000000000000000000000000000fa",
      "value": "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

Get the contract result from a contract on the network executed at a given timestamp

GET

https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/{timestamp}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a single ContractResult for a contract's function executions at a specific timestamp.

Parameters

contractIdOrAddressstringrequiredpath

The ID or hex encoded EVM address (with or without 0x prefix) associated with this contract.

timestampstringrequiredpath

The Unix timestamp in seconds.nanoseconds format, the timestamp at which the associated transaction reached consensus. See unixtimestamp.com for a simple way to convert a date to the 'seconds' part of the Unix time.

Response

200OK

206Partial Content

Partial Content

400Bad Request

Invalid parameter

404Not Found

Not Found

Get the contract result from a contract on the network executed at a given timestamp

curl -X GET 'https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/{timestamp}'

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/{timestamp}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/{timestamp}')
request = Net::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://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/{timestamp}')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/{timestamp}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/{timestamp}";
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://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/{timestamp}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/{timestamp}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/{timestamp}')
request = Net::HTTP::Get.new(uri)

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

{
  "access_list": "0xabcd",
  "address": "0x25fe26adc577cc89172e6156c9e24f7b9751b762",
  "amount": 10,
  "block_gas_used": 2000,
  "block_hash": "0x6ceecd8bb224da491",
  "block_number": 10,
  "call_result": "0x2b048531b38d2882e86044bc972e940ee0a01938",
  "chain_id": "0x0127",
  "contract_id": "0.0.2",
  "created_contract_ids": [
    "0.0.2"
  ],
  "error_message": "Out of gas",
  "failed_initcode": "0x856739",
  "from": "0x0000000000000000000000000000000000001f41",
  "function_parameters": "0xbb9f02dc6f0e3289f57a1f33b71c73aa8548ab8b",
  "gas_consumed": 35000,
  "gas_limit": 100000,
  "gas_price": "0x4a817c800",
  "gas_used": 80000,
  "hash": "0x3531396130303866616264653464",
  "max_fee_per_gas": "0x5",
  "max_priority_fee_per_gas": "0x100",
  "nonce": 1,
  "r": "0xd693b532a80fed6392b428604171fb32fdbf953728a3a7ecc7d4062b1652c043",
  "result": "SUCCESS",
  "s": "0x24e9c602ac800b983b035700a14b23f78a253ab762deab5dc27e3555a750b355",
  "status": 1,
  "timestamp": "1586567700.453054000",
  "to": "0x0000000000000000000000000000000000001f41",
  "transaction_index": 1,
  "type": 2,
  "v": 1,
  "logs": [
    {
      "address": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
      "contract_id": "0.0.2",
      "data": "0x00000000000000000000000000000000000000000000000000000000000000fa",
      "index": 0,
      "topics": [
        "0xf4757a49b326036464bec6fe419a4ae38c8a02ce3e68bf0809674f6aab8ad300"
      ]
    }
  ],
  "state_changes": [
    {
      "address": "0000000000000000000000000000000000001f41",
      "contract_id": "0.0.2",
      "slot": "0x00000000000000000000000000000000000000000000000000000000000000fa",
      "value_read": "0x97c1fc0a6ed5551bc831571325e9bdb365d06803100dc20648640ba24ce69750",
      "value_written": "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"
    }
  ]
}

{
  "access_list": "0xabcd",
  "address": "0x25fe26adc577cc89172e6156c9e24f7b9751b762",
  "amount": 10,
  "block_gas_used": 2000,
  "block_hash": "0x6ceecd8bb224da491",
  "block_number": 10,
  "call_result": "0x2b048531b38d2882e86044bc972e940ee0a01938",
  "chain_id": "0x0127",
  "contract_id": "0.0.2",
  "created_contract_ids": [
    "0.0.2"
  ],
  "error_message": "Out of gas",
  "failed_initcode": "0x856739",
  "from": "0x0000000000000000000000000000000000001f41",
  "function_parameters": "0xbb9f02dc6f0e3289f57a1f33b71c73aa8548ab8b",
  "gas_consumed": 35000,
  "gas_limit": 100000,
  "gas_price": "0x4a817c800",
  "gas_used": 80000,
  "hash": "0x3531396130303866616264653464",
  "max_fee_per_gas": "0x5",
  "max_priority_fee_per_gas": "0x100",
  "nonce": 1,
  "r": "0xd693b532a80fed6392b428604171fb32fdbf953728a3a7ecc7d4062b1652c043",
  "result": "SUCCESS",
  "s": "0x24e9c602ac800b983b035700a14b23f78a253ab762deab5dc27e3555a750b355",
  "status": 1,
  "timestamp": "1586567700.453054000",
  "to": "0x0000000000000000000000000000000000001f41",
  "transaction_index": 1,
  "type": 2,
  "v": 1,
  "logs": [
    {
      "address": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
      "contract_id": "0.0.2",
      "data": "0x00000000000000000000000000000000000000000000000000000000000000fa",
      "index": 0,
      "topics": [
        "0xf4757a49b326036464bec6fe419a4ae38c8a02ce3e68bf0809674f6aab8ad300"
      ]
    }
  ],
  "state_changes": [
    {
      "address": "0000000000000000000000000000000000001f41",
      "contract_id": "0.0.2",
      "slot": "0x00000000000000000000000000000000000000000000000000000000000000fa",
      "value_read": "0x97c1fc0a6ed5551bc831571325e9bdb365d06803100dc20648640ba24ce69750",
      "value_written": "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"
    }
  ]
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

List contract results from all contracts on the network

GET

https://hedera.nownodes.io/api/v1/contracts/results

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of all ContractResults for all contract's function executions.

Parameters

fromstringquery

Account ID or EVM address executing the contract

block.hashstringquery

The block's hash. If multiple values are provided the last value will be the only value used.

block.numberstringquery

The block's number

internalbooleanfalsequery

Whether to include child transactions or not

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescdescquery

The order in which items are listed

timestampArray<string>query

transaction.indexinteger<int32>>= 0query

The transaction index in the block

Response

200OK

400Bad Request

Invalid parameter

List contract results from all contracts on the network

curl -X GET 'https://hedera.nownodes.io/api/v1/contracts/results'

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/results', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/results')
request = Net::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://hedera.nownodes.io/api/v1/contracts/results')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/results', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/contracts/results";
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://hedera.nownodes.io/api/v1/contracts/results', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/contracts/results')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/results')
request = Net::HTTP::Get.new(uri)

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

{
  "results": [
    {
      "access_list": "0xabcd",
      "address": "0x25fe26adc577cc89172e6156c9e24f7b9751b762",
      "amount": 10,
      "block_gas_used": 2000,
      "block_hash": "0x6ceecd8bb224da491",
      "block_number": 10,
      "call_result": "0x2b048531b38d2882e86044bc972e940ee0a01938",
      "chain_id": "0x0127",
      "contract_id": "0.0.2",
      "created_contract_ids": [
        "0.0.2"
      ],
      "error_message": "Out of gas",
      "failed_initcode": "0x856739",
      "from": "0x0000000000000000000000000000000000001f41",
      "function_parameters": "0xbb9f02dc6f0e3289f57a1f33b71c73aa8548ab8b",
      "gas_consumed": 35000,
      "gas_limit": 100000,
      "gas_price": "0x4a817c800",
      "gas_used": 80000,
      "hash": "0xfebbaa29c513d124a6377246ea3506ad917d740c21a88f61a1c55ba338fc2bb1",
      "max_fee_per_gas": "0x5",
      "max_priority_fee_per_gas": "0x100",
      "nonce": 1,
      "r": "0xd693b532a80fed6392b428604171fb32fdbf953728a3a7ecc7d4062b1652c043",
      "result": "SUCCESS",
      "s": "0x24e9c602ac800b983b035700a14b23f78a253ab762deab5dc27e3555a750b355",
      "status": 1,
      "timestamp": "1586567700.453054000",
      "to": "0x0000000000000000000000000000000000001f41",
      "transaction_index": 1,
      "type": 2,
      "v": 1
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

Get the contract result from a contract on the network for a given transactionId or ethereum transaction hash

GET

https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a single ContractResult for a contract's function executions for a given transactionId or ethereum transaction hash.

Parameters

transactionIdOrHashstringrequiredpath

Transaction Id or a 32 byte hash with optional 0x prefix

nonceinteger<int32>>= 00query

Response

200OK

206Partial Content

Partial Content

400Bad Request

Invalid parameter

404Not Found

Not Found

Get the contract result from a contract on the network for a given transactionId or ethereum transaction hash

curl -X GET 'https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}'

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}')
request = Net::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://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}";
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://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}')
request = Net::HTTP::Get.new(uri)

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

{
  "access_list": "0xabcd",
  "address": "0x25fe26adc577cc89172e6156c9e24f7b9751b762",
  "amount": 10,
  "block_gas_used": 2000,
  "block_hash": "0x6ceecd8bb224da491",
  "block_number": 10,
  "call_result": "0x2b048531b38d2882e86044bc972e940ee0a01938",
  "chain_id": "0x0127",
  "contract_id": "0.0.2",
  "created_contract_ids": [
    "0.0.2"
  ],
  "error_message": "Out of gas",
  "failed_initcode": "0x856739",
  "from": "0x0000000000000000000000000000000000001f41",
  "function_parameters": "0xbb9f02dc6f0e3289f57a1f33b71c73aa8548ab8b",
  "gas_consumed": 35000,
  "gas_limit": 100000,
  "gas_price": "0x4a817c800",
  "gas_used": 80000,
  "hash": "0x3531396130303866616264653464",
  "max_fee_per_gas": "0x5",
  "max_priority_fee_per_gas": "0x100",
  "nonce": 1,
  "r": "0xd693b532a80fed6392b428604171fb32fdbf953728a3a7ecc7d4062b1652c043",
  "result": "SUCCESS",
  "s": "0x24e9c602ac800b983b035700a14b23f78a253ab762deab5dc27e3555a750b355",
  "status": 1,
  "timestamp": "1586567700.453054000",
  "to": "0x0000000000000000000000000000000000001f41",
  "transaction_index": 1,
  "type": 2,
  "v": 1,
  "logs": [
    {
      "address": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
      "contract_id": "0.0.2",
      "data": "0x00000000000000000000000000000000000000000000000000000000000000fa",
      "index": 0,
      "topics": [
        "0xf4757a49b326036464bec6fe419a4ae38c8a02ce3e68bf0809674f6aab8ad300"
      ]
    }
  ],
  "state_changes": [
    {
      "address": "0000000000000000000000000000000000001f41",
      "contract_id": "0.0.2",
      "slot": "0x00000000000000000000000000000000000000000000000000000000000000fa",
      "value_read": "0x97c1fc0a6ed5551bc831571325e9bdb365d06803100dc20648640ba24ce69750",
      "value_written": "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"
    }
  ]
}

{
  "access_list": "0xabcd",
  "address": "0x25fe26adc577cc89172e6156c9e24f7b9751b762",
  "amount": 10,
  "block_gas_used": 2000,
  "block_hash": "0x6ceecd8bb224da491",
  "block_number": 10,
  "call_result": "0x2b048531b38d2882e86044bc972e940ee0a01938",
  "chain_id": "0x0127",
  "contract_id": "0.0.2",
  "created_contract_ids": [
    "0.0.2"
  ],
  "error_message": "Out of gas",
  "failed_initcode": "0x856739",
  "from": "0x0000000000000000000000000000000000001f41",
  "function_parameters": "0xbb9f02dc6f0e3289f57a1f33b71c73aa8548ab8b",
  "gas_consumed": 35000,
  "gas_limit": 100000,
  "gas_price": "0x4a817c800",
  "gas_used": 80000,
  "hash": "0x3531396130303866616264653464",
  "max_fee_per_gas": "0x5",
  "max_priority_fee_per_gas": "0x100",
  "nonce": 1,
  "r": "0xd693b532a80fed6392b428604171fb32fdbf953728a3a7ecc7d4062b1652c043",
  "result": "SUCCESS",
  "s": "0x24e9c602ac800b983b035700a14b23f78a253ab762deab5dc27e3555a750b355",
  "status": 1,
  "timestamp": "1586567700.453054000",
  "to": "0x0000000000000000000000000000000000001f41",
  "transaction_index": 1,
  "type": 2,
  "v": 1,
  "logs": [
    {
      "address": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
      "contract_id": "0.0.2",
      "data": "0x00000000000000000000000000000000000000000000000000000000000000fa",
      "index": 0,
      "topics": [
        "0xf4757a49b326036464bec6fe419a4ae38c8a02ce3e68bf0809674f6aab8ad300"
      ]
    }
  ],
  "state_changes": [
    {
      "address": "0000000000000000000000000000000000001f41",
      "contract_id": "0.0.2",
      "slot": "0x00000000000000000000000000000000000000000000000000000000000000fa",
      "value_read": "0x97c1fc0a6ed5551bc831571325e9bdb365d06803100dc20648640ba24ce69750",
      "value_written": "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"
    }
  ]
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

Get the contract actions from a contract on the network for a given transactionId or ethereum transaction hash

GET

https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/actions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of ContractActions for a contract's function executions for a given transactionId or ethereum transaction hash.

Parameters

transactionIdOrHashstringrequiredpath

Transaction Id or a 32 byte hash with optional 0x prefix

indexstringquery

The index of a contract action

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescascquery

The order in which items are listed

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get the contract actions from a contract on the network for a given transactionId or ethereum transaction hash

curl -X GET 'https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/actions'

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/actions', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/actions')
request = Net::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://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/actions')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/actions', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/actions";
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://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/actions', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/actions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/actions')
request = Net::HTTP::Get.new(uri)

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

{
  "actions": [
    {
      "call_depth": 1,
      "call_operation_type": "CALL",
      "call_type": "CALL",
      "caller": "0.0.2",
      "caller_type": "ACCOUNT",
      "from": "0x0000000000000000000000000000000000000065",
      "gas": 50000,
      "gas_used": 50000,
      "index": 0,
      "input": "0x123456",
      "recipient": "0.0.2",
      "recipient_type": "ACCOUNT",
      "result_data": "0x123456",
      "result_data_type": "OUTPUT",
      "timestamp": "1586567700.453054000",
      "to": "0x0000000000000000000000000000000000001f41",
      "value": 50000
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

Get the opcode traces for a historical transaction on the network with the given transaction ID or hash

GET

https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/opcodes

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Re-executes a transaction and returns a result containing detailed information for the execution, including all values from the {@code stack}, {@code memory} and {@code storage} and the entire trace of opcodes that were executed during the replay.

Note that to provide the output, the transaction needs to be re-executed on the EVM, which may take a significant amount of time to complete if stack and memory information is requested.

Parameters

transactionIdOrHashstringrequiredpath

Transaction Id or a 32 byte hash with optional 0x prefix

stackbooleantruequery

If provided and set to false, stack information will not be included in the response

memorybooleanfalsequery

If provided and set to true, memory information will be included in the response

storagebooleanfalsequery

If provided and set to true, storage information will be included in the response

Response

200OK

400Bad Request

Validation error

404Not Found

Transaction or record file not found

429Too Many Requests

Too many requests

Get the opcode traces for a historical transaction on the network with the given transaction ID or hash

curl -X GET 'https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/opcodes'

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/opcodes', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/opcodes')
request = Net::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://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/opcodes')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/opcodes', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/opcodes";
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://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/opcodes', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/opcodes')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/results/{transactionIdOrHash}/opcodes')
request = Net::HTTP::Get.new(uri)

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

{
  "address": "<binary>",
  "contract_id": "0.0.2",
  "failed": true,
  "gas": 0,
  "opcodes": [
    {
      "depth": 0,
      "gas": 0,
      "gas_cost": 0,
      "memory": [
        "<binary>"
      ],
      "op": "string",
      "pc": 0,
      "reason": "<binary>",
      "stack": [
        "<binary>"
      ],
      "storage": {}
    }
  ],
  "return_value": "<binary>"
}

{
  "_status": {
    "messages": [
      {
        "data": "0x3000",
        "detail": "Generic detailed error message",
        "message": "Generic error message"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "data": "0x3000",
        "detail": "Generic detailed error message",
        "message": "Generic error message"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "data": "0x3000",
        "detail": "Generic detailed error message",
        "message": "Generic error message"
      }
    ]
  }
}

List contract logs from a contract on the network

GET

https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/logs

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Search the logs of a specific contract across multiple contract calls. Chained logs are not included but can be found by calling /api/v1/contracts/{contractId}/results/{timestamp} or /api/v1/contracts/results/{transactionId}. When searching by topic a timestamp parameter must be supplied and span a time range of at most seven days.

Ordering

The order is governed by the combination of timestamp and index values. If the index param is omitted, the order is determined by the timestamp only.

Note: The default order for this API is currently DESC

Filtering

When filtering there are some restrictions enforced to ensure correctness and scalability.

The table below defines the restrictions and support for the endpoint

Query Param	Comparison Operator	Support	Description	Example
index	eq	Y	Single occurrence only. Requires the presence of timestamp	?index=X
	ne	N
	lt(e)	Y	Single occurrence only. Requires the presence of timestamp	?index=lte:X
	gt(e)	Y	Single occurrence only. Requires the presence of timestamp	?index=gte:X
timestamp	eq	Y	Single occurrence only.	?timestamp=Y
	ne	N
	lt(e)	Y	Single occurrence only. Optional second timestamp gt(e)	?timestamp=lte:Y
	gt(e)	Y	Single occurrence only. Optional second timestamp lt(e)	?timestamp=gte:Y

Both filters must be a single occurrence of gt(e) or lt(e) which provide a lower and or upper boundary for search.

Parameters

contractIdOrAddressstringrequiredpath

The ID or hex encoded EVM address (with or without 0x prefix) associated with this contract.

indexstringquery

Contract log index

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescdescquery

The order in which items are listed

timestampArray<string>query

topic0Array<string>query

The first topic associated with a contract log. Requires a timestamp range also be populated.

topic1Array<string>query

The second topic associated with a contract log. Requires a timestamp range also be populated.

topic2Array<string>query

The third topic associated with a contract log. Requires a timestamp range also be populated.

topic3Array<string>query

The fourth topic associated with a contract log. Requires a timestamp range also be populated.

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

List contract logs from a contract on the network

curl -X GET 'https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/logs'

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/logs', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/logs')
request = Net::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://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/logs')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/logs', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/logs";
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://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/logs', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/logs')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/{contractIdOrAddress}/results/logs')
request = Net::HTTP::Get.new(uri)

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

{
  "logs": [
    {
      "address": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
      "contract_id": "0.0.2",
      "data": "0x00000000000000000000000000000000000000000000000000000000000000fa",
      "index": 0,
      "topics": [
        "0xf4757a49b326036464bec6fe419a4ae38c8a02ce3e68bf0809674f6aab8ad300"
      ],
      "block_hash": "0x553f9311833391c0a3b2f9ed64540a89f2190a511986cd94889f1c0cf7fa63e898b1c6730f14a61755d1fb4ca05fb073",
      "block_number": 10,
      "timestamp": "1586567700.453054000",
      "transaction_hash": "0x397022d1e5baeb89d0ab66e6bf602640610e6fb7e55d78638db861e2c6339aa9",
      "transaction_index": 1
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

List contracts logs across many contracts on the network

GET

https://hedera.nownodes.io/api/v1/contracts/results/logs

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Search the logs across many contracts with multiple contract calls. Chained logs are not included but can be found by calling /api/v1/contracts/{contractId}/results/{timestamp} or /api/v1/contracts/results/{transactionId}. When searching by topic a timestamp parameter must be supplied and span a time range of at most seven days.

Ordering

The order is governed by the combination of timestamp and index values. If the index param is omitted, the order is determined by the timestamp only.

Note: The default order for this API is currently DESC

Filtering

When filtering there are some restrictions enforced to ensure correctness and scalability.

The table below defines the restrictions and support for the endpoint

Query Param	Comparison Operator	Support	Description	Example
index	eq	Y	Single occurrence only. Requires the presence of timestamp	?index=X
	ne	N
	lt(e)	Y	Single occurrence only. Requires the presence of timestamp	?index=lte:X
	gt(e)	Y	Single occurrence only. Requires the presence of timestamp	?index=gte:X
timestamp	eq	Y	Single occurrence only.	?timestamp=Y
	ne	N
	lt(e)	Y	Single occurrence only. Optional second timestamp gt(e)	?timestamp=lte:Y
	gt(e)	Y	Single occurrence only. Optional second timestamp lt(e)	?timestamp=gte:Y

Both filters must be a single occurrence of gt(e) or lt(e) which provide a lower and or upper boundary for search.

Parameters

indexstringquery

Contract log index

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescdescquery

The order in which items are listed

timestampArray<string>query

topic0Array<string>query

The first topic associated with a contract log. Requires a timestamp range also be populated.

topic1Array<string>query

The second topic associated with a contract log. Requires a timestamp range also be populated.

topic2Array<string>query

The third topic associated with a contract log. Requires a timestamp range also be populated.

topic3Array<string>query

The fourth topic associated with a contract log. Requires a timestamp range also be populated.

transaction.hashstringquery

A hex encoded 32-byte ethereum transaction hash or 48-byte hedera transaction hash.

Response

200OK

400Bad Request

Invalid parameter

List contracts logs across many contracts on the network

curl -X GET 'https://hedera.nownodes.io/api/v1/contracts/results/logs'

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/results/logs', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/results/logs')
request = Net::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://hedera.nownodes.io/api/v1/contracts/results/logs')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/contracts/results/logs', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/contracts/results/logs";
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://hedera.nownodes.io/api/v1/contracts/results/logs', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/contracts/results/logs')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/contracts/results/logs')
request = Net::HTTP::Get.new(uri)

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

{
  "logs": [
    {
      "address": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
      "contract_id": "0.0.2",
      "data": "0x00000000000000000000000000000000000000000000000000000000000000fa",
      "index": 0,
      "topics": [
        "0xf4757a49b326036464bec6fe419a4ae38c8a02ce3e68bf0809674f6aab8ad300"
      ],
      "block_hash": "0x553f9311833391c0a3b2f9ed64540a89f2190a511986cd94889f1c0cf7fa63e898b1c6730f14a61755d1fb4ca05fb073",
      "block_number": 10,
      "timestamp": "1586567700.453054000",
      "transaction_hash": "0x397022d1e5baeb89d0ab66e6bf602640610e6fb7e55d78638db861e2c6339aa9",
      "transaction_index": 1
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

network

Get the network exchange rate to estimate costs

GET

https://hedera.nownodes.io/api/v1/network/exchangerate

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the network's exchange rate, current and next.

Parameters

timestampArray<string>query

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

500Internal Server Error

Service Unavailable

Get the network exchange rate to estimate costs

curl -X GET 'https://hedera.nownodes.io/api/v1/network/exchangerate'

const response = await fetch('https://hedera.nownodes.io/api/v1/network/exchangerate', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/network/exchangerate')
request = Net::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://hedera.nownodes.io/api/v1/network/exchangerate')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/network/exchangerate', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/network/exchangerate')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/network/exchangerate')
request = Net::HTTP::Get.new(uri)

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

{
  "current_rate": {
    "cent_equivalent": 596987,
    "expiration_time": 1649689200,
    "hbar_equivalent": 30000
  },
  "next_rate": {
    "cent_equivalent": 596987,
    "expiration_time": 1649689200,
    "hbar_equivalent": 30000
  },
  "timestamp": "1586567700.453054000"
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Require at least 1/3 signature files to prove consensus, got 1 out of 4 for file 2019-10-11T13_33_25.526889Z.rcd_sig"
      }
    ]
  }
}

Get the network fees

GET

https://hedera.nownodes.io/api/v1/network/fees

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the estimated gas in tinybars per each transaction type. Default order is ASC. Currently only ContractCall, ContractCreate and EthereumTransaction transaction types are supported.

Parameters

orderanyascdescascquery

The order in which items are listed

timestampArray<string>query

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

500Internal Server Error

Service Unavailable

Get the network fees

curl -X GET 'https://hedera.nownodes.io/api/v1/network/fees'

const response = await fetch('https://hedera.nownodes.io/api/v1/network/fees', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/network/fees')
request = Net::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://hedera.nownodes.io/api/v1/network/fees')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/network/fees', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/network/fees')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/network/fees')
request = Net::HTTP::Get.new(uri)

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

{
  "fees": [
    {
      "gas": 0,
      "transaction_type": "string"
    }
  ],
  "timestamp": "1586567700.453054000"
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Require at least 1/3 signature files to prove consensus, got 1 out of 4 for file 2019-10-11T13_33_25.526889Z.rcd_sig"
      }
    ]
  }
}

Get the network address book nodes

GET

https://hedera.nownodes.io/api/v1/network/nodes

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the network's list of nodes used in consensus

Parameters

file.idEntityIdQueryquery

The ID of the file entity

limitinteger<int32>[1, 100]25query

The maximum number of items to return

node.idstringquery

The ID of the node

orderanyascdescascquery

The order in which items are listed

Response

200OK

400Bad Request

Invalid parameter

Get the network address book nodes

curl -X GET 'https://hedera.nownodes.io/api/v1/network/nodes'

const response = await fetch('https://hedera.nownodes.io/api/v1/network/nodes', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/network/nodes')
request = Net::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://hedera.nownodes.io/api/v1/network/nodes')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/network/nodes', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/network/nodes')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/network/nodes')
request = Net::HTTP::Get.new(uri)

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

{
  "nodes": [
    {
      "admin_key": {
        "_type": "ED25519",
        "key": "15706b229b3ba33d4a5a41ff54ce1cfe0a3d308672a33ff382f81583e02bd743"
      },
      "decline_reward": false,
      "description": "address book 1",
      "file_id": "0.0.102",
      "max_stake": 50000,
      "memo": "0.0.4",
      "min_stake": 1000,
      "node_account_id": "0.0.4",
      "node_cert_hash": "0x01d173753810c0aae794ba72d5443c292e9ff962b01046220dd99f5816422696e0569c977e2f169e1e5688afc8f4aa16",
      "node_id": 1,
      "public_key": "0x4a5ad514f0957fa170a676210c9bdbddf3bc9519702cf915fa6767a40463b96f",
      "reward_rate_start": 1000000,
      "service_endpoints": [
        {
          "ip_address_v4": "128.0.0.6",
          "port": 50216
        }
      ],
      "stake": 20000,
      "stake_not_rewarded": 19900,
      "stake_rewarded": 100,
      "staking_period": {
        "from": "1655164800.000000000",
        "to": "1655251200.000000000"
      },
      "timestamp": {
        "from": "187654.000123457",
        "to": null
      }
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

Get network stake information

GET

https://hedera.nownodes.io/api/v1/network/stake

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the network's current stake information.

Response

200OK

400Bad Request

Invalid parameter

404Not Found

No network stake data found

500Internal Server Error

Service Unavailable

Get network stake information

curl -X GET 'https://hedera.nownodes.io/api/v1/network/stake'

const response = await fetch('https://hedera.nownodes.io/api/v1/network/stake', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/network/stake')
request = Net::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://hedera.nownodes.io/api/v1/network/stake')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/network/stake', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/network/stake')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/network/stake')
request = Net::HTTP::Get.new(uri)

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

{
  "max_stake_rewarded": 10,
  "max_staking_reward_rate_per_hbar": 17808,
  "max_total_reward": 20,
  "node_reward_fee_fraction": 1,
  "reserved_staking_rewards": 30,
  "reward_balance_threshold": 40,
  "stake_total": 35000000000000000,
  "staking_period": {
    "from": "1655164800.000000000",
    "to": "1655251200.000000000"
  },
  "staking_period_duration": 1440,
  "staking_periods_stored": 365,
  "staking_reward_fee_fraction": 1,
  "staking_reward_rate": 100000000000,
  "staking_start_threshold": 25000000000000000,
  "unreserved_staking_reward_balance": 50
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "detail": "No network stake data found",
        "message": "Not Found"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Require at least 1/3 signature files to prove consensus, got 1 out of 4 for file 2019-10-11T13_33_25.526889Z.rcd_sig"
      }
    ]
  }
}

Get the network supply

GET

https://hedera.nownodes.io/api/v1/network/supply

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the network's released supply of hbars

Parameters

timestampArray<string>query

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get the network supply

curl -X GET 'https://hedera.nownodes.io/api/v1/network/supply'

const response = await fetch('https://hedera.nownodes.io/api/v1/network/supply', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/network/supply')
request = Net::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://hedera.nownodes.io/api/v1/network/supply')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/network/supply', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/network/supply')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/network/supply')
request = Net::HTTP::Get.new(uri)

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

{
  "released_supply": "3999999999999999949",
  "total_supply": "5000000000000000000"
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

schedules

List schedules entities

GET

https://hedera.nownodes.io/api/v1/schedules

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Lists schedules on the network that govern the execution logic of scheduled transactions. This includes executed and non executed schedules.

Parameters

account.idEntityIdQueryquery

The ID of the account to return information for

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescascquery

The order in which items are listed

schedule.idEntityIdQueryquery

The ID of the schedule to return information for

Response

200OK

400Bad Request

Invalid parameter

List schedules entities

curl -X GET 'https://hedera.nownodes.io/api/v1/schedules'

const response = await fetch('https://hedera.nownodes.io/api/v1/schedules', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/schedules')
request = Net::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://hedera.nownodes.io/api/v1/schedules')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/schedules', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/schedules')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/schedules')
request = Net::HTTP::Get.new(uri)

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

{
  "schedules": [
    {
      "admin_key": {
        "_type": "ProtobufEncoded",
        "key": "15706b229b3ba33d4a5a41ff54ce1cfe0a3d308672a33ff382f81583e02bd743"
      },
      "consensus_timestamp": "1586567700.453054000",
      "creator_account_id": "0.0.2",
      "deleted": false,
      "executed_timestamp": "1586567700.453054000",
      "expiration_time": "1586567700.453054000",
      "memo": "created on 02/10/2021",
      "payer_account_id": "0.0.2",
      "schedule_id": "0.0.2",
      "signatures": [
        {
          "consensus_timestamp": "1586567700.453054000",
          "public_key_prefix": "AAEBAwuqAwzB",
          "signature": "3q2+7wABAQMLqgMMwQ==",
          "type": "ED25519"
        }
      ],
      "transaction_body": "Kd6tvu8=",
      "wait_for_expiry": true
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

Get schedule by id

GET

https://hedera.nownodes.io/api/v1/schedules/{scheduleId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns schedule information based on the given schedule id

Parameters

scheduleIdEntityId | nullrequiredpath

Schedule id

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get schedule by id

curl -X GET 'https://hedera.nownodes.io/api/v1/schedules/{scheduleId}'

const response = await fetch('https://hedera.nownodes.io/api/v1/schedules/{scheduleId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/schedules/{scheduleId}')
request = Net::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://hedera.nownodes.io/api/v1/schedules/{scheduleId}')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/schedules/{scheduleId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/schedules/{scheduleId}";
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://hedera.nownodes.io/api/v1/schedules/{scheduleId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/schedules/{scheduleId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/schedules/{scheduleId}')
request = Net::HTTP::Get.new(uri)

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

{
  "admin_key": {
    "_type": "ProtobufEncoded",
    "key": "15706b229b3ba33d4a5a41ff54ce1cfe0a3d308672a33ff382f81583e02bd743"
  },
  "consensus_timestamp": "1586567700.453054000",
  "creator_account_id": "0.0.2",
  "deleted": false,
  "executed_timestamp": "1586567700.453054000",
  "expiration_time": "1586567700.453054000",
  "memo": "created on 02/10/2021",
  "payer_account_id": "0.0.2",
  "schedule_id": "0.0.2",
  "signatures": [
    {
      "consensus_timestamp": "1586567700.453054000",
      "public_key_prefix": "AAEBAwuqAwzB",
      "signature": "3q2+7wABAQMLqgMMwQ==",
      "type": "ED25519"
    }
  ],
  "transaction_body": "Kd6tvu8=",
  "wait_for_expiry": true
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

transactions

List transactions

GET

https://hedera.nownodes.io/api/v1/transactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Lists transactions on the network. This includes successful and unsuccessful transactions.

Parameters

account.idEntityIdQueryquery

The ID of the account to return information for

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescdescquery

The order in which items are listed

timestampArray<string>query

resultanysuccessfailquery

The transaction success type.

typeanycreditdebitquery

The transaction account balance modification type.

Response

200OK

400Bad Request

Invalid parameter

List transactions

curl -X GET 'https://hedera.nownodes.io/api/v1/transactions'

const response = await fetch('https://hedera.nownodes.io/api/v1/transactions', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/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://hedera.nownodes.io/api/v1/transactions')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/transactions', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/transactions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/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": [
    {
      "batch_key": "0xae8bebf1c9fa0f309356e48057f6047af7cde63037d0509d16ddc3b20e085158bfdf14d15345c1b18b199b72fed4dead",
      "bytes": null,
      "charged_tx_fee": 7,
      "consensus_timestamp": "1234567890.000000007",
      "entity_id": "0.0.2281979",
      "max_custom_fees": [
        {
          "account_id": "0.0.8",
          "amount": 1000,
          "denominating_token_id": "0.0.2000"
        },
        {
          "account_id": "0.0.8",
          "amount": 1500,
          "denominating_token_id": null
        }
      ],
      "max_fee": 33,
      "memo_base64": null,
      "name": "CRYPTOTRANSFER",
      "nft_transfers": [
        {
          "is_approval": true,
          "receiver_account_id": "0.0.121",
          "sender_account_id": "0.0.122",
          "serial_number": 1,
          "token_id": "0.0.123"
        },
        {
          "is_approval": true,
          "receiver_account_id": "0.0.321",
          "sender_account_id": "0.0.422",
          "serial_number": 2,
          "token_id": "0.0.123"
        }
      ],
      "node": "0.0.3",
      "nonce": 0,
      "parent_consensus_timestamp": "1234567890.000000007",
      "result": "SUCCESS",
      "scheduled": false,
      "staking_reward_transfers": [
        {
          "account": 3,
          "amount": 150
        },
        {
          "account": 9,
          "amount": 200
        }
      ],
      "transaction_hash": "vigzKe2J7fv4ktHBbNTSzQmKq7Lzdq1/lJMmHT+a2KgvdhAuadlvS4eKeqKjIRmW",
      "transaction_id": "0.0.8-1234567890-000000006",
      "token_transfers": [
        {
          "token_id": "0.0.90000",
          "account": "0.0.9",
          "amount": 1200,
          "is_approval": false
        },
        {
          "token_id": "0.0.90000",
          "account": "0.0.8",
          "amount": -1200,
          "is_approval": false
        }
      ],
      "transfers": [
        {
          "account": "0.0.3",
          "amount": 2,
          "is_approval": false
        },
        {
          "account": "0.0.8",
          "amount": -3,
          "is_approval": false
        },
        {
          "account": "0.0.98",
          "amount": 1,
          "is_approval": false
        },
        {
          "account": "0.0.800",
          "amount": 150,
          "is_approval": false
        },
        {
          "account": "0.0.800",
          "amount": 200,
          "is_approval": false
        }
      ],
      "valid_duration_seconds": 11,
      "valid_start_timestamp": "1234567890.000000006"
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

Get transaction by id

GET

https://hedera.nownodes.io/api/v1/transactions/{transactionId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns transaction information based on the given transaction id

Parameters

transactionIdstringrequiredpath

Transaction id

nonceinteger<int32>>= 0query

Filter the query result by the nonce of the transaction. A zero nonce represents user submitted transactions while a non-zero nonce is generated by main nodes. The filter honors the last value. If not specified, all transactions with specified payer account ID and valid start timestamp match. If multiple values are provided the last value will be the only value used.

scheduledbooleanquery

Filter transactions by the scheduled flag. If true, return information for the scheduled transaction. If false, return information for the non-scheduled transaction. If not present, return information for all transactions matching transactionId. If multiple values are provided the last value will be the only value used.

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get transaction by id

curl -X GET 'https://hedera.nownodes.io/api/v1/transactions/{transactionId}'

const response = await fetch('https://hedera.nownodes.io/api/v1/transactions/{transactionId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/transactions/{transactionId}')
request = Net::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://hedera.nownodes.io/api/v1/transactions/{transactionId}')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/transactions/{transactionId}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/transactions/{transactionId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/transactions/{transactionId}')
request = Net::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": [
    {
      "assessed_custom_fees": [
        {
          "amount": 100,
          "collector_account_id": "0.0.10",
          "effective_payer_account_ids": [
            "0.0.8",
            "0.0.72"
          ],
          "token_id": "0.0.90001"
        }
      ],
      "bytes": null,
      "charged_tx_fee": 7,
      "consensus_timestamp": "1234567890.000000007",
      "entity_id": "0.0.2281979",
      "max_fee": 33,
      "memo_base64": null,
      "name": "CRYPTOTRANSFER",
      "nft_transfers": [
        {
          "is_approval": true,
          "receiver_account_id": "0.0.121",
          "sender_account_id": "0.0.122",
          "serial_number": 1,
          "token_id": "0.0.123"
        },
        {
          "is_approval": true,
          "receiver_account_id": "0.0.321",
          "sender_account_id": "0.0.422",
          "serial_number": 2,
          "token_id": "0.0.123"
        }
      ],
      "node": "0.0.3",
      "nonce": 0,
      "parent_consensus_timestamp": "1234567890.000000007",
      "result": "SUCCESS",
      "scheduled": false,
      "staking_reward_transfers": [
        {
          "account": 3,
          "amount": 200
        },
        {
          "account": 9,
          "amount": 300
        }
      ],
      "transaction_hash": "vigzKe2J7fv4ktHBbNTSzQmKq7Lzdq1/lJMmHT+a2KgvdhAuadlvS4eKeqKjIRmW",
      "transaction_id": "0.0.8-1234567890-000000006",
      "token_transfers": [
        {
          "token_id": "0.0.90000",
          "account": "0.0.9",
          "amount": 1200,
          "is_approval": true
        },
        {
          "token_id": "0.0.90000",
          "account": "0.0.8",
          "amount": -1200,
          "is_approval": true
        }
      ],
      "transfers": [
        {
          "account": "0.0.3",
          "amount": 2,
          "is_approval": true
        },
        {
          "account": "0.0.8",
          "amount": -3,
          "is_approval": true
        },
        {
          "account": "0.0.98",
          "amount": 1,
          "is_approval": true
        },
        {
          "account": "0.0.800",
          "amount": 200,
          "is_approval": false
        },
        {
          "account": "0.0.800",
          "amount": 300,
          "is_approval": false
        }
      ],
      "valid_duration_seconds": 11,
      "valid_start_timestamp": "1234567890.000000006"
    }
  ]
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

topics

Get topic by ID

GET

https://hedera.nownodes.io/api/v1/topics/{topicId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the topic details for the given topic ID.

Parameters

topicIdEntityId | nullrequiredpath

Topic id

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get topic by ID

curl -X GET 'https://hedera.nownodes.io/api/v1/topics/{topicId}'

const response = await fetch('https://hedera.nownodes.io/api/v1/topics/{topicId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/topics/{topicId}')
request = Net::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://hedera.nownodes.io/api/v1/topics/{topicId}')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/topics/{topicId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/topics/{topicId}";
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://hedera.nownodes.io/api/v1/topics/{topicId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/topics/{topicId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/topics/{topicId}')
request = Net::HTTP::Get.new(uri)

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

{
  "admin_key": {
    "_type": "ProtobufEncoded",
    "key": "15706b229b3ba33d4a5a41ff54ce1cfe0a3d308672a33ff382f81583e02bd743"
  },
  "auto_renew_account": "0.0.2",
  "auto_renew_period": 7776000,
  "created_timestamp": "1586567700.453054000",
  "custom_fees": {
    "created_timestamp": "1586567700.453054000",
    "fixed_fees": [
      {
        "amount": 100,
        "collector_account_id": "0.0.2",
        "denominating_token_id": "0.0.2"
      }
    ]
  },
  "deleted": false,
  "fee_exempt_key_list": [
    {
      "_type": "ProtobufEncoded",
      "key": "15706b229b3ba33d4a5a41ff54ce1cfe0a3d308672a33ff382f81583e02bd743"
    }
  ],
  "fee_schedule_key": {
    "_type": "ProtobufEncoded",
    "key": "15706b229b3ba33d4a5a41ff54ce1cfe0a3d308672a33ff382f81583e02bd743"
  },
  "memo": "topic memo",
  "submit_key": {
    "_type": "ProtobufEncoded",
    "key": "15706b229b3ba33d4a5a41ff54ce1cfe0a3d308672a33ff382f81583e02bd743"
  },
  "timestamp": {},
  "topic_id": "0.0.2"
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

List topic messages by id

GET

https://hedera.nownodes.io/api/v1/topics/{topicId}/messages

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the list of topic messages for the given topic id.

Parameters

topicIdEntityId | nullrequiredpath

Topic id

encodingstringquery

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescascquery

The order in which items are listed

sequencenumberinteger<int64>>= 0query

timestampArray<string>query

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Topic Not Found

List topic messages by id

curl -X GET 'https://hedera.nownodes.io/api/v1/topics/{topicId}/messages'

const response = await fetch('https://hedera.nownodes.io/api/v1/topics/{topicId}/messages', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/topics/{topicId}/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://hedera.nownodes.io/api/v1/topics/{topicId}/messages')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/topics/{topicId}/messages', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/topics/{topicId}/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://hedera.nownodes.io/api/v1/topics/{topicId}/messages', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/topics/{topicId}/messages')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/topics/{topicId}/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": [
    {
      "chunk_info": {
        "initial_transaction_id": "0.0.10-1234567890-000000321",
        "nonce": 3,
        "number": 1,
        "total": 2,
        "scheduled": true
      },
      "consensus_timestamp": "1234567890.000000001",
      "message": "bWVzc2FnZQ==",
      "payer_account_id": "0.0.10",
      "running_hash": "cnVubmluZ19oYXNo",
      "running_hash_version": 2,
      "sequence_number": 1,
      "topic_id": "0.0.7"
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "No such topic id - 7"
      }
    ]
  }
}

Get topic message by id and sequence number

GET

https://hedera.nownodes.io/api/v1/topics/{topicId}/messages/{sequenceNumber}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a single topic message for the given topic id and sequence number.

Parameters

topicIdEntityId | nullrequiredpath

Topic id

sequenceNumberinteger<int64>>= 0requiredpath

Topic message sequence number

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get topic message by id and sequence number

curl -X GET 'https://hedera.nownodes.io/api/v1/topics/{topicId}/messages/{sequenceNumber}'

const response = await fetch('https://hedera.nownodes.io/api/v1/topics/{topicId}/messages/{sequenceNumber}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/topics/{topicId}/messages/{sequenceNumber}')
request = Net::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://hedera.nownodes.io/api/v1/topics/{topicId}/messages/{sequenceNumber}')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/topics/{topicId}/messages/{sequenceNumber}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/topics/{topicId}/messages/{sequenceNumber}";
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://hedera.nownodes.io/api/v1/topics/{topicId}/messages/{sequenceNumber}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/topics/{topicId}/messages/{sequenceNumber}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/topics/{topicId}/messages/{sequenceNumber}')
request = Net::HTTP::Get.new(uri)

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

{
  "chunk_info": {
    "initial_transaction_id": "0.0.10-1234567890-000000321",
    "nonce": 3,
    "number": 1,
    "total": 2,
    "scheduled": true
  },
  "consensus_timestamp": "1234567890.000000001",
  "message": "bWVzc2FnZQ==",
  "payer_account_id": "0.0.10",
  "running_hash": "cnVubmluZ19oYXNo",
  "running_hash_version": 2,
  "sequence_number": 1,
  "topic_id": "0.0.7"
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

Get topic message by consensusTimestamp

GET

https://hedera.nownodes.io/api/v1/topics/messages/{timestamp}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a topic message the given the consensusTimestamp.

Parameters

timestampstringrequiredpath

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get topic message by consensusTimestamp

curl -X GET 'https://hedera.nownodes.io/api/v1/topics/messages/{timestamp}'

const response = await fetch('https://hedera.nownodes.io/api/v1/topics/messages/{timestamp}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/topics/messages/{timestamp}')
request = Net::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://hedera.nownodes.io/api/v1/topics/messages/{timestamp}')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/topics/messages/{timestamp}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/topics/messages/{timestamp}";
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://hedera.nownodes.io/api/v1/topics/messages/{timestamp}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/topics/messages/{timestamp}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/topics/messages/{timestamp}')
request = Net::HTTP::Get.new(uri)

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

{
  "chunk_info": {
    "initial_transaction_id": "0.0.10-1234567890-000000321",
    "nonce": 3,
    "number": 1,
    "total": 2,
    "scheduled": true
  },
  "consensus_timestamp": "1234567890.000000001",
  "message": "bWVzc2FnZQ==",
  "payer_account_id": "0.0.10",
  "running_hash": "cnVubmluZ19oYXNo",
  "running_hash_version": 2,
  "sequence_number": 1,
  "topic_id": "0.0.7"
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

tokens

List tokens

GET

https://hedera.nownodes.io/api/v1/tokens

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of tokens on the network.

Parameters

account.idEntityIdQueryquery

The ID of the account to return information for

limitinteger<int32>[1, 100]25query

The maximum number of items to return

namestringquery

Partial or full token name. Not allowed to be used with token.id or account.id parameter. Pagination is not supported with the use of this parameter and results are ordered by token.id with respect to the order parameter.

orderanyascdescascquery

The order in which items are listed

publickeystringquery

The public key to compare against

token.idEntityIdQueryquery

The ID of the token to return information for

typeArray<string>query

Response

200OK

400Bad Request

Invalid parameter

List tokens

curl -X GET 'https://hedera.nownodes.io/api/v1/tokens'

const response = await fetch('https://hedera.nownodes.io/api/v1/tokens', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/tokens')
request = Net::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://hedera.nownodes.io/api/v1/tokens')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/tokens', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/tokens')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/tokens')
request = Net::HTTP::Get.new(uri)

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

{
  "tokens": [
    {
      "admin_key": null,
      "decimals": 3,
      "metadata": "VGhpcyBpcyBhIHRlc3QgTkZU",
      "name": "First Mover",
      "symbol": "FIRSTMOVERLPDJH",
      "token_id": "0.0.1",
      "type": "FUNGIBLE_COMMON"
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

Get token by id

GET

https://hedera.nownodes.io/api/v1/tokens/{tokenId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns token entity information given the id

Parameters

tokenIdEntityId | nullrequiredpath

Token id

timestampstringquery

The Unix timestamp in seconds.nanoseconds format. See unixtimestamp.com for a simple way to convert a date to the 'seconds' part of the Unix time.

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get token by id

curl -X GET 'https://hedera.nownodes.io/api/v1/tokens/{tokenId}'

const response = await fetch('https://hedera.nownodes.io/api/v1/tokens/{tokenId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/tokens/{tokenId}')
request = Net::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://hedera.nownodes.io/api/v1/tokens/{tokenId}')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/tokens/{tokenId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/tokens/{tokenId}";
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://hedera.nownodes.io/api/v1/tokens/{tokenId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/tokens/{tokenId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/tokens/{tokenId}')
request = Net::HTTP::Get.new(uri)

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

{
  "admin_key": {
    "_type": "ProtobufEncoded",
    "key": 10101
  },
  "auto_renew_account": "0.1.2",
  "auto_renew_period": null,
  "created_timestamp": "1234567890.000000001",
  "deleted": false,
  "decimals": 1000,
  "expiry_timestamp": null,
  "freeze_default": false,
  "freeze_key": {
    "_type": "ProtobufEncoded",
    "key": 10101
  },
  "initial_supply": 1000000,
  "kyc_key": {
    "_type": "ProtobufEncoded",
    "key": 10101
  },
  "max_supply": 9223372036854776000,
  "memo": "token memo",
  "modified_timestamp": "1234567890.000000001",
  "name": "Token name",
  "pause_key": {
    "_type": "ProtobufEncoded",
    "key": 10101
  },
  "pause_status": "UNPAUSED",
  "supply_key": {
    "_type": "ProtobufEncoded",
    "key": 10101
  },
  "supply_type": "INFINITE",
  "symbol": "ORIGINALRDKSE",
  "token_id": "0.10.1",
  "total_supply": 1000000,
  "treasury_account_id": "0.1.2",
  "type": "FUNGIBLE_COMMON",
  "wipe_key": {
    "_type": "ProtobufEncoded",
    "key": 10101
  },
  "custom_fees": {
    "created_timestamp": "1234567890.000000001",
    "fixed_fees": [
      {
        "amount": 100,
        "collector_account_id": "0.1.5",
        "denominating_token_id": "0.10.8"
      }
    ],
    "fractional_fees": [
      {
        "amount": {
          "numerator": 12,
          "denominator": 29
        },
        "collector_account_id": "0.1.6",
        "denominating_token_id": "0.10.9",
        "maximum": 120,
        "minimum": 30,
        "net_of_transfers": true
      }
    ]
  }
}

{
  "admin_key": {
    "_type": "ProtobufEncoded",
    "key": 10101
  },
  "auto_renew_account": "0.1.2",
  "auto_renew_period": null,
  "created_timestamp": "1234567890.000000001",
  "deleted": false,
  "decimals": 0,
  "expiry_timestamp": null,
  "freeze_default": false,
  "freeze_key": {
    "_type": "ProtobufEncoded",
    "key": 10101
  },
  "initial_supply": 0,
  "kyc_key": {
    "_type": "ProtobufEncoded",
    "key": 10101
  },
  "max_supply": 9223372036854776000,
  "memo": "token memo",
  "modified_timestamp": "1234567890.000000001",
  "name": "Token name",
  "pause_key": {
    "_type": "ProtobufEncoded",
    "key": 10101
  },
  "pause_status": "UNPAUSED",
  "supply_key": {
    "_type": "ProtobufEncoded",
    "key": 10101
  },
  "supply_type": "INFINITE",
  "symbol": "ORIGINALRDKSE",
  "token_id": "0.10.1",
  "total_supply": 1000000,
  "treasury_account_id": "0.1.2",
  "type": "NON_FUNGIBLE_UNIQUE",
  "wipe_key": {
    "_type": "ProtobufEncoded",
    "key": 10101
  },
  "custom_fees": {
    "created_timestamp": "1234567890.000000001",
    "fixed_fees": [
      {
        "amount": 100,
        "collector_account_id": "0.1.5",
        "denominating_token_id": "0.10.6"
      }
    ],
    "royalty_fees": [
      {
        "amount": {
          "numerator": 15,
          "denominator": 37
        },
        "collector_account_id": "0.1.6",
        "fallback_fee": {
          "amount": 100,
          "denominating_token_id": "0.10.7"
        }
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

List token balances

GET

https://hedera.nownodes.io/api/v1/tokens/{tokenId}/balances

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of token balances given the id. This represents the Token supply distribution across the network

Parameters

tokenIdEntityId | nullrequiredpath

Token id

account.balancestringquery

The optional balance value to compare against

account.idEntityIdQueryquery

The ID of the account to return information for

account.publickeystringquery

The account's public key to compare against

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescdescquery

The order in which items are listed

timestampArray<string>query

Response

200OK

400Bad Request

Invalid parameter

List token balances

curl -X GET 'https://hedera.nownodes.io/api/v1/tokens/{tokenId}/balances'

const response = await fetch('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/balances', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/balances')
request = Net::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://hedera.nownodes.io/api/v1/tokens/{tokenId}/balances')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/balances', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/tokens/{tokenId}/balances";
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://hedera.nownodes.io/api/v1/tokens/{tokenId}/balances', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/balances')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/balances')
request = Net::HTTP::Get.new(uri)

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

{
  "timestamp": "1586567700.453054000",
  "balances": [
    {
      "account": "0.15.2",
      "balance": 1000,
      "decimals": 3
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

List nfts

GET

https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of non-fungible tokens

Parameters

tokenIdEntityId | nullrequiredpath

Token id

account.idEntityIdQueryquery

The ID of the account to return information for

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescdescquery

The order in which items are listed

serialnumberstringquery

The nft serial number (64 bit type). Requires a tokenId value also be populated.

Response

200OK

400Bad Request

Invalid parameter

List nfts

curl -X GET 'https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts'

const response = await fetch('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts')
request = Net::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://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts";
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://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts')
request = Net::HTTP::Get.new(uri)

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

{
  "nfts": [
    {
      "account_id": "0.1.2",
      "created_timestamp": "1234567890.000000001",
      "delegating_spender": "0.0.400",
      "deleted": false,
      "metadata": "VGhpcyBpcyBhIHRlc3QgTkZU",
      "modified_timestamp": "1610682445.003266001",
      "serial_number": 124,
      "spender_id": "0.0.500",
      "token_id": "0.0.222"
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

Get nft info

GET

https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information for a non-fungible token

Parameters

tokenIdEntityId | nullrequiredpath

Token id

serialNumberinteger<int64>[1, 9223372036854776000]1requiredpath

The nft serial number

Response

200OK

400Bad Request

Invalid parameter

404Not Found

Not Found

Get nft info

curl -X GET 'https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}'

const response = await fetch('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}')
request = Net::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://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}";
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://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}')
request = Net::HTTP::Get.new(uri)

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

{
  "account_id": "0.1.2",
  "created_timestamp": "1234567890.000000001",
  "delegating_spender": "0.0.400",
  "deleted": false,
  "metadata": "VGhpcyBpcyBhIHRlc3QgTkZU",
  "modified_timestamp": "1610682445.003266001",
  "serial_number": 124,
  "spender_id": "0.0.500",
  "token_id": "0.0.222"
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Not found"
      }
    ]
  }
}

Get an nfts transction history

GET

https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}/transactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of transactions for a given non-fungible token

Parameters

tokenIdEntityId | nullrequiredpath

Token id

serialNumberinteger<int64>[1, 9223372036854776000]1requiredpath

The nft serial number

limitinteger<int32>[1, 100]25query

The maximum number of items to return

orderanyascdescdescquery

The order in which items are listed

timestampArray<string>query

Response

200OK

206Partial Content

Partial Content

400Bad Request

Invalid parameter

Get an nfts transction history

curl -X GET 'https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}/transactions'

const response = await fetch('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}/transactions', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}/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://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}/transactions')
data = response.json()

const response = await fetch('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}/transactions', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}/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://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}/transactions', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}/transactions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://hedera.nownodes.io/api/v1/tokens/{tokenId}/nfts/{serialNumber}/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": [
    {
      "consensus_timestamp": "1618591023.997420021",
      "is_approval": false,
      "nonce": 0,
      "receiver_account_id": "0.0.11",
      "sender_account_id": "0.0.10",
      "transaction_id": "0.0.19789-1618591023-997420021",
      "type": "CRYPTOTRANSFER"
    }
  ],
  "links": {
    "next": null
  }
}

{
  "transactions": [
    {
      "consensus_timestamp": "1618591023.997420021",
      "is_approval": false,
      "nonce": 0,
      "receiver_account_id": "0.0.11",
      "sender_account_id": "0.0.10",
      "transaction_id": "0.0.19789-1618591023-997420021",
      "type": "CRYPTOTRANSFER"
    }
  ],
  "links": {
    "next": null
  }
}

{
  "_status": {
    "messages": [
      {
        "message": "Invalid parameter: account.id"
      },
      {
        "message": "Invalid Transaction id. Please use \\shard.realm.num-sss-nnn\\ format where sss are seconds and nnn are nanoseconds"
      }
    ]
  }
}

Documentation

How to migrate to NOWNodes

Authentication

Node

accounts

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Ordering

Filtering

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Ordering

Filtering

Parameters

Response

Authorizations

Ordering

Filtering

Parameters

Response

airdrops

Authorizations

Parameters

Response

Authorizations

Parameters

Response

balances

Authorizations

Parameters

Response

blocks

Authorizations

Parameters

Response

Authorizations

Parameters

Response

contracts

Authorizations

Body

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters