Chain API

v1.0.0

Base URL

https://eos.nownodes.io/v1/chain

OAS 3.0 Nodeos Chain API Specification

Authentication

api-keyAuthapiKey

API Key: api-key in header

Chain

POST

https://eos.nownodes.io/v1/chain/get_account

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an object containing various details about a specific account on the blockchain.

Body

application/json

JSON Object with single member "account_name"

account_namestring | string | string | stringrequired

Response

200OK

POST /get_account

curl -X POST 'https://eos.nownodes.io/v1/chain/get_account' \
  -H 'Content-Type: application/json' \
  -d '{
    "account_name": "string"
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/get_account', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "account_name": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_account')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "account_name": "string"
  }'

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

import requests

payload = {
  "account_name": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_account', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/get_account', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "account_name": "string"
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/get_account";
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({
    "account_name": "string"
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/get_account', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "account_name": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "account_name": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_account', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_account')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "account_name": "string"
  }'

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

Request Body

{
  "account_name": "string"
}

200

{
  "account_name": "string",
  "head_block_num": 0,
  "head_block_time": "string",
  "last_code_update": "string",
  "created": "string",
  "refund_request": {
    "owner": "string",
    "request_time": "string",
    "net_amount": "string",
    "cpu_amount": "string"
  },
  "ram_quota": "string",
  "net_limit": {
    "max": "string",
    "available": "string",
    "used": "string"
  },
  "cpu_limit": {
    "max": "string",
    "available": "string",
    "used": "string"
  },
  "total_resources": {
    "owner": "string",
    "ram_bytes": "string",
    "net_weight": "string",
    "cpu_weight": "string"
  },
  "core_liquid_balance": "string",
  "self_delegated_bandwidth": {
    "from": "string",
    "to": "string",
    "net_weight": "string",
    "cpu_weight": "string"
  },
  "net_weight": "string",
  "cpu_weight": "string",
  "ram_usage": "string",
  "privileged": true,
  "permissions": [
    {
      "parent": "string",
      "perm_name": "string",
      "required_auth": {
        "waits": [
          {
            "wait_sec": 0,
            "weight": 0
          }
        ],
        "keys": [
          {
            "key": "string",
            "weight": 0
          }
        ],
        "threshold": 0,
        "accounts": [
          {
            "weight": 0,
            "permission": {
              "actor": "string",
              "permission": "string"
            }
          }
        ]
      }
    }
  ],
  "voter_info": {
    "owner": "string",
    "proxy": "string",
    "producers": [
      "string"
    ],
    "staked": "string",
    "last_vote_weight": "string",
    "proxied_vote_weight": "string",
    "is_proxy": 0,
    "flags1": 0,
    "reserved2": 0,
    "reserved3": "string"
  }
}

POST

https://eos.nownodes.io/v1/chain/get_block

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an object containing various details about a specific block on the blockchain.

Body

application/json

block_num_or_idstringrequired

Provide a block number or a block id

Response

200OK

POST /get_block

curl -X POST 'https://eos.nownodes.io/v1/chain/get_block' \
  -H 'Content-Type: application/json' \
  -d '{
    "block_num_or_id": "string"
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/get_block', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "block_num_or_id": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_block')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "block_num_or_id": "string"
  }'

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

import requests

payload = {
  "block_num_or_id": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_block', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/get_block', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "block_num_or_id": "string"
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/get_block";
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_num_or_id": "string"
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/get_block', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "block_num_or_id": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "block_num_or_id": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_block', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_block')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "block_num_or_id": "string"
  }'

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

Request Body

{
  "block_num_or_id": "string"
}

200

{
  "timestamp": "string",
  "producer": "string",
  "confirmed": 0,
  "previous": "string",
  "transaction_mroot": "string",
  "action_mroot": "string",
  "schedule_version": 0,
  "new_producers": {
    "version": 0,
    "producers": [
      {
        "producer_name": "string",
        "block_signing_key": "string"
      }
    ]
  },
  "header_extensions": [
    0
  ],
  "new_protocol_features": [
    {}
  ],
  "producer_signature": "string",
  "transactions": [
    {
      "status": "executed",
      "cpu_usage_us": 0,
      "net_usage_words": 0,
      "trx": "string"
    }
  ],
  "block_extensions": [
    0
  ],
  "id": "string",
  "block_num": 0,
  "ref_block_prefix": 0
}

POST

https://eos.nownodes.io/v1/chain/get_block_info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Similar to get_block but returns a fixed-size smaller subset of the block data.

Body

application/json

block_numintegerrequired

Provide a block number

Response

200OK

POST /get_block_info

curl -X POST 'https://eos.nownodes.io/v1/chain/get_block_info' \
  -H 'Content-Type: application/json' \
  -d '{
    "block_num": 0
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/get_block_info', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "block_num": 0
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_block_info')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "block_num": 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_num": 0
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_block_info', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/get_block_info', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "block_num": 0
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/get_block_info";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://eos.nownodes.io/v1/chain/get_block_info', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "block_num": 0
    }),
});

const data = await response.json();

import requests

payload = {
  "block_num": 0
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_block_info', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_block_info')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "block_num": 0
  }'

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

Request Body

{
  "block_num": 0
}

200

{
  "block_num": 0,
  "ref_block_num": 0,
  "id": "string",
  "timestamp": "string",
  "producer": "string",
  "confirmed": 0,
  "previous": "string",
  "transaction_mroot": "string",
  "action_mroot": "string",
  "schedule_version": 0,
  "producer_signature": "string",
  "ref_block_prefix": 0
}

POST

https://eos.nownodes.io/v1/chain/get_info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an object containing various details about the blockchain.

Response

200OK

POST /get_info

curl -X POST 'https://eos.nownodes.io/v1/chain/get_info'

const response = await fetch('https://eos.nownodes.io/v1/chain/get_info', {
  method: 'POST',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_info')
request = Net::HTTP::Post.new(uri)

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

import requests

response = requests.post('https://eos.nownodes.io/v1/chain/get_info')
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/get_info', {
  method: 'POST',
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/get_info";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://eos.nownodes.io/v1/chain/get_info', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://eos.nownodes.io/v1/chain/get_info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_info')
request = Net::HTTP::Post.new(uri)

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

200

{
  "server_version": "string",
  "chain_id": "string",
  "head_block_num": 0,
  "head_block_id": "string",
  "head_block_time": "string",
  "head_block_producer": "string",
  "last_irreversible_block_num": 0,
  "last_irreversible_block_id": "string",
  "virtual_block_cpu_limit": 0,
  "virtual_block_net_limit": 0,
  "block_cpu_limit": 0,
  "block_net_limit": 0,
  "server_version_string": "string",
  "fork_db_head_block_num": 0,
  "fork_db_head_block_id": "string"
}

POST

https://eos.nownodes.io/v1/chain/push_transaction

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

This method expects a transaction in JSON format and will attempt to apply it to the blockchain.

Body

application/json

signaturesArray<items>

array of signatures required to authorize transaction

compressionboolean

Compression used, usually false

packed_context_free_datastring

json to hex

packed_trxstring

Transaction object json to hex

Response

200OK

POST /push_transaction

curl -X POST 'https://eos.nownodes.io/v1/chain/push_transaction' \
  -H 'Content-Type: application/json' \
  -d '{
    "signatures": [
      "string"
    ],
    "compression": true,
    "packed_context_free_data": "string",
    "packed_trx": "string"
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/push_transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "signatures": [
        "string"
      ],
      "compression": true,
      "packed_context_free_data": "string",
      "packed_trx": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/push_transaction')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "signatures": [
      "string"
    ],
    "compression": true,
    "packed_context_free_data": "string",
    "packed_trx": "string"
  }'

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

import requests

payload = {
  "signatures": [
    "string"
  ],
  "compression": True,
  "packed_context_free_data": "string",
  "packed_trx": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/push_transaction', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/push_transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "signatures": [
        "string"
      ],
      "compression": true,
      "packed_context_free_data": "string",
      "packed_trx": "string"
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/push_transaction";
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({
    "signatures": [
      "string"
    ],
    "compression": true,
    "packed_context_free_data": "string",
    "packed_trx": "string"
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/push_transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "signatures": [
        "string"
      ],
      "compression": true,
      "packed_context_free_data": "string",
      "packed_trx": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "signatures": [
    "string"
  ],
  "compression": True,
  "packed_context_free_data": "string",
  "packed_trx": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/push_transaction', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/push_transaction')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "signatures": [
      "string"
    ],
    "compression": true,
    "packed_context_free_data": "string",
    "packed_trx": "string"
  }'

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

Request Body

{
  "signatures": [
    "string"
  ],
  "compression": true,
  "packed_context_free_data": "string",
  "packed_trx": "string"
}

POST

https://eos.nownodes.io/v1/chain/send_transaction

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

This method expects a transaction in JSON format and will attempt to apply it to the blockchain.

Body

application/json

signaturesArray<items>

array of signatures required to authorize transaction

compressionboolean

Compression used, usually false

packed_context_free_datastring

json to hex

packed_trxstring

Transaction object json to hex

Response

200OK

POST /send_transaction

curl -X POST 'https://eos.nownodes.io/v1/chain/send_transaction' \
  -H 'Content-Type: application/json' \
  -d '{
    "signatures": [
      "string"
    ],
    "compression": true,
    "packed_context_free_data": "string",
    "packed_trx": "string"
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/send_transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "signatures": [
        "string"
      ],
      "compression": true,
      "packed_context_free_data": "string",
      "packed_trx": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/send_transaction')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "signatures": [
      "string"
    ],
    "compression": true,
    "packed_context_free_data": "string",
    "packed_trx": "string"
  }'

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

import requests

payload = {
  "signatures": [
    "string"
  ],
  "compression": True,
  "packed_context_free_data": "string",
  "packed_trx": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/send_transaction', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/send_transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "signatures": [
        "string"
      ],
      "compression": true,
      "packed_context_free_data": "string",
      "packed_trx": "string"
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/send_transaction";
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({
    "signatures": [
      "string"
    ],
    "compression": true,
    "packed_context_free_data": "string",
    "packed_trx": "string"
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/send_transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "signatures": [
        "string"
      ],
      "compression": true,
      "packed_context_free_data": "string",
      "packed_trx": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "signatures": [
    "string"
  ],
  "compression": True,
  "packed_context_free_data": "string",
  "packed_trx": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/send_transaction', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/send_transaction')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "signatures": [
      "string"
    ],
    "compression": true,
    "packed_context_free_data": "string",
    "packed_trx": "string"
  }'

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

Request Body

{
  "signatures": [
    "string"
  ],
  "compression": true,
  "packed_context_free_data": "string",
  "packed_trx": "string"
}

POST

https://eos.nownodes.io/v1/chain/push_transactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

This method expects a transaction in JSON format and will attempt to apply it to the blockchain.

Body

application/json

Array<items>

Show child attributes

expirationstringrequired

Time that transaction must be confirmed by.

ref_block_numintegerrequired

ref_block_prefixintegerrequired

32-bit portion of block ID

max_net_usage_wordsstring | integerrequired

A whole number

max_cpu_usage_msstring | integerrequired

A whole number

delay_secintegerrequired

context_free_actionsArray<items>required

Show child attributes

accountstring | string | string | stringrequired

namestring | string | string | stringrequired

authorizationArray<1>required

Show child attributes

actorstring | string | string | stringrequired

permissionstring | string | string | stringrequired

dataobjectrequired

hex_datastringrequired

actionsArray<items>required

Show child attributes

accountstring | string | string | stringrequired

namestring | string | string | stringrequired

authorizationArray<1>required

Show child attributes

actorstring | string | string | stringrequired

permissionstring | string | string | stringrequired

dataobjectrequired

hex_datastringrequired

transaction_extensionsArray<block_extensions>

Response

200OK

POST /push_transactions

curl -X POST 'https://eos.nownodes.io/v1/chain/push_transactions' \
  -H 'Content-Type: application/json' \
  -d '[
    {
      "expiration": "string",
      "ref_block_num": 0,
      "ref_block_prefix": 0,
      "max_net_usage_words": "string",
      "max_cpu_usage_ms": "string",
      "delay_sec": 0,
      "context_free_actions": [
        {
          "account": "string",
          "name": "string",
          "authorization": [
            {
              "actor": "string",
              "permission": "string"
            }
          ],
          "data": {},
          "hex_data": "string"
        }
      ],
      "actions": [
        {
          "account": "string",
          "name": "string",
          "authorization": [
            {
              "actor": "string",
              "permission": "string"
            }
          ],
          "data": {},
          "hex_data": "string"
        }
      ],
      "transaction_extensions": [
        [
          0
        ]
      ]
    }
  ]'

const response = await fetch('https://eos.nownodes.io/v1/chain/push_transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify([
      {
        "expiration": "string",
        "ref_block_num": 0,
        "ref_block_prefix": 0,
        "max_net_usage_words": "string",
        "max_cpu_usage_ms": "string",
        "delay_sec": 0,
        "context_free_actions": [
          {
            "account": "string",
            "name": "string",
            "authorization": [
              {
                "actor": "string",
                "permission": "string"
              }
            ],
            "data": {},
            "hex_data": "string"
          }
        ],
        "actions": [
          {
            "account": "string",
            "name": "string",
            "authorization": [
              {
                "actor": "string",
                "permission": "string"
              }
            ],
            "data": {},
            "hex_data": "string"
          }
        ],
        "transaction_extensions": [
          [
            0
          ]
        ]
      }
    ]),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/push_transactions')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '[
    {
      "expiration": "string",
      "ref_block_num": 0,
      "ref_block_prefix": 0,
      "max_net_usage_words": "string",
      "max_cpu_usage_ms": "string",
      "delay_sec": 0,
      "context_free_actions": [
        {
          "account": "string",
          "name": "string",
          "authorization": [
            {
              "actor": "string",
              "permission": "string"
            }
          ],
          "data": {},
          "hex_data": "string"
        }
      ],
      "actions": [
        {
          "account": "string",
          "name": "string",
          "authorization": [
            {
              "actor": "string",
              "permission": "string"
            }
          ],
          "data": {},
          "hex_data": "string"
        }
      ],
      "transaction_extensions": [
        [
          0
        ]
      ]
    }
  ]'

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

import requests

payload = [
  {
    "expiration": "string",
    "ref_block_num": 0,
    "ref_block_prefix": 0,
    "max_net_usage_words": "string",
    "max_cpu_usage_ms": "string",
    "delay_sec": 0,
    "context_free_actions": [
      {
        "account": "string",
        "name": "string",
        "authorization": [
          {
            "actor": "string",
            "permission": "string"
          }
        ],
        "data": {},
        "hex_data": "string"
      }
    ],
    "actions": [
      {
        "account": "string",
        "name": "string",
        "authorization": [
          {
            "actor": "string",
            "permission": "string"
          }
        ],
        "data": {},
        "hex_data": "string"
      }
    ],
    "transaction_extensions": [
      [
        0
      ]
    ]
  }
]

response = requests.post('https://eos.nownodes.io/v1/chain/push_transactions', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/push_transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify([
      {
        "expiration": "string",
        "ref_block_num": 0,
        "ref_block_prefix": 0,
        "max_net_usage_words": "string",
        "max_cpu_usage_ms": "string",
        "delay_sec": 0,
        "context_free_actions": [
          {
            "account": "string",
            "name": "string",
            "authorization": [
              {
                "actor": "string",
                "permission": "string"
              }
            ],
            "data": {},
            "hex_data": "string"
          }
        ],
        "actions": [
          {
            "account": "string",
            "name": "string",
            "authorization": [
              {
                "actor": "string",
                "permission": "string"
              }
            ],
            "data": {},
            "hex_data": "string"
          }
        ],
        "transaction_extensions": [
          [
            0
          ]
        ]
      }
    ]),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/push_transactions";
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([
    {
      "expiration": "string",
      "ref_block_num": 0,
      "ref_block_prefix": 0,
      "max_net_usage_words": "string",
      "max_cpu_usage_ms": "string",
      "delay_sec": 0,
      "context_free_actions": [
        {
          "account": "string",
          "name": "string",
          "authorization": [
            {
              "actor": "string",
              "permission": "string"
            }
          ],
          "data": {},
          "hex_data": "string"
        }
      ],
      "actions": [
        {
          "account": "string",
          "name": "string",
          "authorization": [
            {
              "actor": "string",
              "permission": "string"
            }
          ],
          "data": {},
          "hex_data": "string"
        }
      ],
      "transaction_extensions": [
        [
          0
        ]
      ]
    }
  ]);
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/push_transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify([
      {
        "expiration": "string",
        "ref_block_num": 0,
        "ref_block_prefix": 0,
        "max_net_usage_words": "string",
        "max_cpu_usage_ms": "string",
        "delay_sec": 0,
        "context_free_actions": [
          {
            "account": "string",
            "name": "string",
            "authorization": [
              {
                "actor": "string",
                "permission": "string"
              }
            ],
            "data": {},
            "hex_data": "string"
          }
        ],
        "actions": [
          {
            "account": "string",
            "name": "string",
            "authorization": [
              {
                "actor": "string",
                "permission": "string"
              }
            ],
            "data": {},
            "hex_data": "string"
          }
        ],
        "transaction_extensions": [
          [
            0
          ]
        ]
      }
    ]),
});

const data = await response.json();

import requests

payload = [
  {
    "expiration": "string",
    "ref_block_num": 0,
    "ref_block_prefix": 0,
    "max_net_usage_words": "string",
    "max_cpu_usage_ms": "string",
    "delay_sec": 0,
    "context_free_actions": [
      {
        "account": "string",
        "name": "string",
        "authorization": [
          {
            "actor": "string",
            "permission": "string"
          }
        ],
        "data": {},
        "hex_data": "string"
      }
    ],
    "actions": [
      {
        "account": "string",
        "name": "string",
        "authorization": [
          {
            "actor": "string",
            "permission": "string"
          }
        ],
        "data": {},
        "hex_data": "string"
      }
    ],
    "transaction_extensions": [
      [
        0
      ]
    ]
  }
]

response = requests.post('https://eos.nownodes.io/v1/chain/push_transactions', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/push_transactions')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '[
    {
      "expiration": "string",
      "ref_block_num": 0,
      "ref_block_prefix": 0,
      "max_net_usage_words": "string",
      "max_cpu_usage_ms": "string",
      "delay_sec": 0,
      "context_free_actions": [
        {
          "account": "string",
          "name": "string",
          "authorization": [
            {
              "actor": "string",
              "permission": "string"
            }
          ],
          "data": {},
          "hex_data": "string"
        }
      ],
      "actions": [
        {
          "account": "string",
          "name": "string",
          "authorization": [
            {
              "actor": "string",
              "permission": "string"
            }
          ],
          "data": {},
          "hex_data": "string"
        }
      ],
      "transaction_extensions": [
        [
          0
        ]
      ]
    }
  ]'

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

Request Body

[
  {
    "expiration": "string",
    "ref_block_num": 0,
    "ref_block_prefix": 0,
    "max_net_usage_words": "string",
    "max_cpu_usage_ms": "string",
    "delay_sec": 0,
    "context_free_actions": [
      {
        "account": "string",
        "name": "string",
        "authorization": [
          {
            "actor": "string",
            "permission": "string"
          }
        ],
        "data": {},
        "hex_data": "string"
      }
    ],
    "actions": [
      {
        "account": "string",
        "name": "string",
        "authorization": [
          {
            "actor": "string",
            "permission": "string"
          }
        ],
        "data": {},
        "hex_data": "string"
      }
    ],
    "transaction_extensions": [
      [
        0
      ]
    ]
  }
]

POST

https://eos.nownodes.io/v1/chain/get_block_header_state

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieves the glock header state

Body

application/json

block_num_or_idstringrequired

Provide a block_number or a block_id

Response

200OK

POST /get_block_header_state

curl -X POST 'https://eos.nownodes.io/v1/chain/get_block_header_state' \
  -H 'Content-Type: application/json' \
  -d '{
    "block_num_or_id": "string"
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/get_block_header_state', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "block_num_or_id": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_block_header_state')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "block_num_or_id": "string"
  }'

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

import requests

payload = {
  "block_num_or_id": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_block_header_state', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/get_block_header_state', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "block_num_or_id": "string"
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/get_block_header_state";
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_num_or_id": "string"
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/get_block_header_state', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "block_num_or_id": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "block_num_or_id": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_block_header_state', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_block_header_state')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "block_num_or_id": "string"
  }'

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

Request Body

{
  "block_num_or_id": "string"
}

200

{
  "id": "string",
  "block_num": 0,
  "header": {
    "timestamp": "string",
    "producer": "string",
    "confirmed": 0,
    "previous": "string",
    "transaction_mroot": "string",
    "action_mroot": "string",
    "schedule_version": 0,
    "new_producers": {
      "version": 0,
      "producers": [
        {
          "producer_name": "string",
          "block_signing_key": "string"
        }
      ]
    },
    "header_extensions": [
      0
    ],
    "new_protocol_features": [
      {}
    ],
    "producer_signature": "string",
    "transactions": [
      {
        "status": "executed",
        "cpu_usage_us": 0,
        "net_usage_words": 0,
        "trx": "string"
      }
    ],
    "block_extensions": [
      0
    ],
    "id": "string",
    "block_num": 0,
    "ref_block_prefix": 0
  },
  "dpos_proposed_irreversible_blocknum": "string",
  "dpos_irreversible_blocknum": "string",
  "bft_irreversible_blocknum": "string",
  "pending_schedule_lib_num": "string",
  "pending_schedule_hash": "string",
  "pending_schedule": {
    "version": 0,
    "producers": [
      {
        "producer_name": "string",
        "block_signing_key": "string"
      }
    ]
  },
  "active_schedule": {
    "version": 0,
    "producers": [
      {
        "producer_name": "string",
        "block_signing_key": "string"
      }
    ]
  },
  "blockroot_merkle": {
    "_active_nodes": [
      "string"
    ],
    "_node_count": "string"
  },
  "producer_to_last_produced": [
    [
      "string"
    ]
  ],
  "producer_to_last_implied_irb": [
    [
      "string"
    ]
  ],
  "block_signing_key": "string",
  "confirm_count": [
    "string"
  ],
  "confirmations": []
}

POST

https://eos.nownodes.io/v1/chain/get_abi

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieves the ABI for a contract based on its account name

Body

application/json

account_namestring | string | string | stringrequired

Response

200OK

POST /get_abi

curl -X POST 'https://eos.nownodes.io/v1/chain/get_abi' \
  -H 'Content-Type: application/json' \
  -d '{
    "account_name": "string"
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/get_abi', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "account_name": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_abi')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "account_name": "string"
  }'

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

import requests

payload = {
  "account_name": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_abi', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/get_abi', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "account_name": "string"
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/get_abi";
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({
    "account_name": "string"
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/get_abi', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "account_name": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "account_name": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_abi', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_abi')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "account_name": "string"
  }'

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

Request Body

{
  "account_name": "string"
}

200

{
  "version": "string",
  "types": [
    {
      "new_type_name": "string",
      "type": "uint8"
    }
  ],
  "structs": [
    {
      "name": "string",
      "base": "string",
      "fields": [
        {
          "name": "string",
          "type": "uint8"
        }
      ]
    }
  ],
  "actions": [
    {
      "name": "string",
      "type": "string",
      "ricardian_contract": "string"
    }
  ],
  "tables": [
    {
      "name": "string",
      "index_type": "i64",
      "key_names": [
        "string"
      ],
      "key_types": [
        "uint64"
      ],
      "type": "string"
    }
  ],
  "abi_extensions": [
    [
      0
    ]
  ],
  "error_messages": [
    "string"
  ],
  "ricardian_clauses": [
    "string"
  ],
  "variants": [
    "string"
  ]
}

POST

https://eos.nownodes.io/v1/chain/get_currency_balance

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieves the current balance

Body

application/json

codestring | string | string | stringrequired

accountstring | string | string | stringrequired

symbolitemsrequired

A string representation of an EOSIO symbol, composed of a float with a precision of 4, and a symbol composed of capital letters between 1-7 letters separated by a space, example 1.0000 ABC.

Response

200OK

POST /get_currency_balance

curl -X POST 'https://eos.nownodes.io/v1/chain/get_currency_balance' \
  -H 'Content-Type: application/json' \
  -d '{
    "code": "string",
    "account": "string",
    "symbol": "string"
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/get_currency_balance', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "account": "string",
      "symbol": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_currency_balance')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "string",
    "account": "string",
    "symbol": "string"
  }'

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

import requests

payload = {
  "code": "string",
  "account": "string",
  "symbol": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_currency_balance', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/get_currency_balance', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "account": "string",
      "symbol": "string"
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/get_currency_balance";
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({
    "code": "string",
    "account": "string",
    "symbol": "string"
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/get_currency_balance', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "account": "string",
      "symbol": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "code": "string",
  "account": "string",
  "symbol": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_currency_balance', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_currency_balance')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "string",
    "account": "string",
    "symbol": "string"
  }'

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

Request Body

{
  "code": "string",
  "account": "string",
  "symbol": "string"
}

200

[
  "string"
]

POST

https://eos.nownodes.io/v1/chain/get_currency_stats

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieves currency stats

Body

application/json

codestring | string | string | string

symbolitems

A string representation of an EOSIO symbol, composed of a float with a precision of 4, and a symbol composed of capital letters between 1-7 letters separated by a space, example 1.0000 ABC.

Response

200OK

POST /get_currency_stats

curl -X POST 'https://eos.nownodes.io/v1/chain/get_currency_stats' \
  -H 'Content-Type: application/json' \
  -d '{
    "code": "string",
    "symbol": "string"
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/get_currency_stats', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "symbol": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_currency_stats')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "string",
    "symbol": "string"
  }'

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

import requests

payload = {
  "code": "string",
  "symbol": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_currency_stats', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/get_currency_stats', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "symbol": "string"
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/get_currency_stats";
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({
    "code": "string",
    "symbol": "string"
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/get_currency_stats', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "symbol": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "code": "string",
  "symbol": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_currency_stats', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_currency_stats')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "string",
    "symbol": "string"
  }'

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

Request Body

{
  "code": "string",
  "symbol": "string"
}

POST

https://eos.nownodes.io/v1/chain/get_required_keys

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the required keys needed to sign a transaction.

Body

application/json

transactionitemsrequired

Show child attributes

expirationstringrequired

Time that transaction must be confirmed by.

ref_block_numintegerrequired

ref_block_prefixintegerrequired

32-bit portion of block ID

max_net_usage_wordsstring | integerrequired

A whole number

max_cpu_usage_msstring | integerrequired

A whole number

delay_secintegerrequired

context_free_actionsArray<items>required

Show child attributes

accountstring | string | string | stringrequired

namestring | string | string | stringrequired

authorizationArray<1>required

Show child attributes

actorstring | string | string | stringrequired

permissionstring | string | string | stringrequired

dataobjectrequired

hex_datastringrequired

actionsArray<items>required

Show child attributes

accountstring | string | string | stringrequired

namestring | string | string | stringrequired

authorizationArray<1>required

Show child attributes

actorstring | string | string | stringrequired

permissionstring | string | string | stringrequired

dataobjectrequired

hex_datastringrequired

transaction_extensionsArray<block_extensions>

available_keysArray<items>required

Provide the available keys

Response

200OK

POST /get_required_keys

curl -X POST 'https://eos.nownodes.io/v1/chain/get_required_keys' \
  -H 'Content-Type: application/json' \
  -d '{
    "transaction": {
      "expiration": "string",
      "ref_block_num": 0,
      "ref_block_prefix": 0,
      "max_net_usage_words": "string",
      "max_cpu_usage_ms": "string",
      "delay_sec": 0,
      "context_free_actions": [
        {
          "account": "string",
          "name": "string",
          "authorization": [
            {
              "actor": "string",
              "permission": "string"
            }
          ],
          "data": {},
          "hex_data": "string"
        }
      ],
      "actions": [
        {
          "account": "string",
          "name": "string",
          "authorization": [
            {
              "actor": "string",
              "permission": "string"
            }
          ],
          "data": {},
          "hex_data": "string"
        }
      ],
      "transaction_extensions": [
        [
          0
        ]
      ]
    },
    "available_keys": [
      "string"
    ]
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/get_required_keys', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "transaction": {
        "expiration": "string",
        "ref_block_num": 0,
        "ref_block_prefix": 0,
        "max_net_usage_words": "string",
        "max_cpu_usage_ms": "string",
        "delay_sec": 0,
        "context_free_actions": [
          {
            "account": "string",
            "name": "string",
            "authorization": [
              {
                "actor": "string",
                "permission": "string"
              }
            ],
            "data": {},
            "hex_data": "string"
          }
        ],
        "actions": [
          {
            "account": "string",
            "name": "string",
            "authorization": [
              {
                "actor": "string",
                "permission": "string"
              }
            ],
            "data": {},
            "hex_data": "string"
          }
        ],
        "transaction_extensions": [
          [
            0
          ]
        ]
      },
      "available_keys": [
        "string"
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_required_keys')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "transaction": {
      "expiration": "string",
      "ref_block_num": 0,
      "ref_block_prefix": 0,
      "max_net_usage_words": "string",
      "max_cpu_usage_ms": "string",
      "delay_sec": 0,
      "context_free_actions": [
        {
          "account": "string",
          "name": "string",
          "authorization": [
            {
              "actor": "string",
              "permission": "string"
            }
          ],
          "data": {},
          "hex_data": "string"
        }
      ],
      "actions": [
        {
          "account": "string",
          "name": "string",
          "authorization": [
            {
              "actor": "string",
              "permission": "string"
            }
          ],
          "data": {},
          "hex_data": "string"
        }
      ],
      "transaction_extensions": [
        [
          0
        ]
      ]
    },
    "available_keys": [
      "string"
    ]
  }'

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

import requests

payload = {
  "transaction": {
    "expiration": "string",
    "ref_block_num": 0,
    "ref_block_prefix": 0,
    "max_net_usage_words": "string",
    "max_cpu_usage_ms": "string",
    "delay_sec": 0,
    "context_free_actions": [
      {
        "account": "string",
        "name": "string",
        "authorization": [
          {
            "actor": "string",
            "permission": "string"
          }
        ],
        "data": {},
        "hex_data": "string"
      }
    ],
    "actions": [
      {
        "account": "string",
        "name": "string",
        "authorization": [
          {
            "actor": "string",
            "permission": "string"
          }
        ],
        "data": {},
        "hex_data": "string"
      }
    ],
    "transaction_extensions": [
      [
        0
      ]
    ]
  },
  "available_keys": [
    "string"
  ]
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_required_keys', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/get_required_keys', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "transaction": {
        "expiration": "string",
        "ref_block_num": 0,
        "ref_block_prefix": 0,
        "max_net_usage_words": "string",
        "max_cpu_usage_ms": "string",
        "delay_sec": 0,
        "context_free_actions": [
          {
            "account": "string",
            "name": "string",
            "authorization": [
              {
                "actor": "string",
                "permission": "string"
              }
            ],
            "data": {},
            "hex_data": "string"
          }
        ],
        "actions": [
          {
            "account": "string",
            "name": "string",
            "authorization": [
              {
                "actor": "string",
                "permission": "string"
              }
            ],
            "data": {},
            "hex_data": "string"
          }
        ],
        "transaction_extensions": [
          [
            0
          ]
        ]
      },
      "available_keys": [
        "string"
      ]
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/get_required_keys";
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({
    "transaction": {
      "expiration": "string",
      "ref_block_num": 0,
      "ref_block_prefix": 0,
      "max_net_usage_words": "string",
      "max_cpu_usage_ms": "string",
      "delay_sec": 0,
      "context_free_actions": [
        {
          "account": "string",
          "name": "string",
          "authorization": [
            {
              "actor": "string",
              "permission": "string"
            }
          ],
          "data": {},
          "hex_data": "string"
        }
      ],
      "actions": [
        {
          "account": "string",
          "name": "string",
          "authorization": [
            {
              "actor": "string",
              "permission": "string"
            }
          ],
          "data": {},
          "hex_data": "string"
        }
      ],
      "transaction_extensions": [
        [
          0
        ]
      ]
    },
    "available_keys": [
      "string"
    ]
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/get_required_keys', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "transaction": {
        "expiration": "string",
        "ref_block_num": 0,
        "ref_block_prefix": 0,
        "max_net_usage_words": "string",
        "max_cpu_usage_ms": "string",
        "delay_sec": 0,
        "context_free_actions": [
          {
            "account": "string",
            "name": "string",
            "authorization": [
              {
                "actor": "string",
                "permission": "string"
              }
            ],
            "data": {},
            "hex_data": "string"
          }
        ],
        "actions": [
          {
            "account": "string",
            "name": "string",
            "authorization": [
              {
                "actor": "string",
                "permission": "string"
              }
            ],
            "data": {},
            "hex_data": "string"
          }
        ],
        "transaction_extensions": [
          [
            0
          ]
        ]
      },
      "available_keys": [
        "string"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "transaction": {
    "expiration": "string",
    "ref_block_num": 0,
    "ref_block_prefix": 0,
    "max_net_usage_words": "string",
    "max_cpu_usage_ms": "string",
    "delay_sec": 0,
    "context_free_actions": [
      {
        "account": "string",
        "name": "string",
        "authorization": [
          {
            "actor": "string",
            "permission": "string"
          }
        ],
        "data": {},
        "hex_data": "string"
      }
    ],
    "actions": [
      {
        "account": "string",
        "name": "string",
        "authorization": [
          {
            "actor": "string",
            "permission": "string"
          }
        ],
        "data": {},
        "hex_data": "string"
      }
    ],
    "transaction_extensions": [
      [
        0
      ]
    ]
  },
  "available_keys": [
    "string"
  ]
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_required_keys', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_required_keys')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "transaction": {
      "expiration": "string",
      "ref_block_num": 0,
      "ref_block_prefix": 0,
      "max_net_usage_words": "string",
      "max_cpu_usage_ms": "string",
      "delay_sec": 0,
      "context_free_actions": [
        {
          "account": "string",
          "name": "string",
          "authorization": [
            {
              "actor": "string",
              "permission": "string"
            }
          ],
          "data": {},
          "hex_data": "string"
        }
      ],
      "actions": [
        {
          "account": "string",
          "name": "string",
          "authorization": [
            {
              "actor": "string",
              "permission": "string"
            }
          ],
          "data": {},
          "hex_data": "string"
        }
      ],
      "transaction_extensions": [
        [
          0
        ]
      ]
    },
    "available_keys": [
      "string"
    ]
  }'

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

Request Body

{
  "transaction": {
    "expiration": "string",
    "ref_block_num": 0,
    "ref_block_prefix": 0,
    "max_net_usage_words": "string",
    "max_cpu_usage_ms": "string",
    "delay_sec": 0,
    "context_free_actions": [
      {
        "account": "string",
        "name": "string",
        "authorization": [
          {
            "actor": "string",
            "permission": "string"
          }
        ],
        "data": {},
        "hex_data": "string"
      }
    ],
    "actions": [
      {
        "account": "string",
        "name": "string",
        "authorization": [
          {
            "actor": "string",
            "permission": "string"
          }
        ],
        "data": {},
        "hex_data": "string"
      }
    ],
    "transaction_extensions": [
      [
        0
      ]
    ]
  },
  "available_keys": [
    "string"
  ]
}

POST

https://eos.nownodes.io/v1/chain/get_producers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieves producers list

Body

application/json

limitstringrequired

total number of producers to retrieve

lower_boundstringrequired

In conjunction with limit can be used to paginate through the results. For example, limit=10 and lower_bound=10 would be page 2

jsonboolean

return result in JSON format

Response

200OK

POST /get_producers

curl -X POST 'https://eos.nownodes.io/v1/chain/get_producers' \
  -H 'Content-Type: application/json' \
  -d '{
    "limit": "string",
    "lower_bound": "string",
    "json": true
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/get_producers', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "limit": "string",
      "lower_bound": "string",
      "json": true
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_producers')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "limit": "string",
    "lower_bound": "string",
    "json": true
  }'

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

import requests

payload = {
  "limit": "string",
  "lower_bound": "string",
  "json": True
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_producers', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/get_producers', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "limit": "string",
      "lower_bound": "string",
      "json": true
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/get_producers";
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({
    "limit": "string",
    "lower_bound": "string",
    "json": true
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/get_producers', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "limit": "string",
      "lower_bound": "string",
      "json": true
    }),
});

const data = await response.json();

import requests

payload = {
  "limit": "string",
  "lower_bound": "string",
  "json": True
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_producers', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_producers')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "limit": "string",
    "lower_bound": "string",
    "json": true
  }'

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

Request Body

{
  "limit": "string",
  "lower_bound": "string",
  "json": true
}

200

{
  "active": [
    {
      "version": 0,
      "producers": [
        {
          "producer_name": "string",
          "block_signing_key": "string"
        }
      ]
    }
  ],
  "pending": [
    {
      "version": 0,
      "producers": [
        {
          "producer_name": "string",
          "block_signing_key": "string"
        }
      ]
    }
  ],
  "proposed": [
    {
      "version": 0,
      "producers": [
        {
          "producer_name": "string",
          "block_signing_key": "string"
        }
      ]
    }
  ]
}

POST

https://eos.nownodes.io/v1/chain/get_raw_code_and_abi

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieves raw code and ABI for a contract based on account name

Body

application/json

account_namestring | string | string | stringrequired

Response

200OK

POST /get_raw_code_and_abi

curl -X POST 'https://eos.nownodes.io/v1/chain/get_raw_code_and_abi' \
  -H 'Content-Type: application/json' \
  -d '{
    "account_name": "string"
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/get_raw_code_and_abi', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "account_name": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_raw_code_and_abi')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "account_name": "string"
  }'

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

import requests

payload = {
  "account_name": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_raw_code_and_abi', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/get_raw_code_and_abi', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "account_name": "string"
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/get_raw_code_and_abi";
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({
    "account_name": "string"
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/get_raw_code_and_abi', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "account_name": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "account_name": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_raw_code_and_abi', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_raw_code_and_abi')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "account_name": "string"
  }'

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

Request Body

{
  "account_name": "string"
}

200

{
  "account_name": "string",
  "wasm": "string",
  "abi": "string"
}

POST

https://eos.nownodes.io/v1/chain/get_scheduled_transaction

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieves the scheduled transaction

Body

application/json

lower_boundlower_bound

Date/time string in the format YYYY-MM-DDTHH:MM:SS.sss

limitinteger

The maximum number of transactions to return

jsonboolean

true/false whether the packed transaction is converted to json

Response

200OK

POST /get_scheduled_transaction

curl -X POST 'https://eos.nownodes.io/v1/chain/get_scheduled_transaction' \
  -H 'Content-Type: application/json' \
  -d '{
    "lower_bound": "string",
    "limit": 0,
    "json": true
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/get_scheduled_transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "lower_bound": "string",
      "limit": 0,
      "json": true
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_scheduled_transaction')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "lower_bound": "string",
    "limit": 0,
    "json": true
  }'

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

import requests

payload = {
  "lower_bound": "string",
  "limit": 0,
  "json": True
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_scheduled_transaction', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/get_scheduled_transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "lower_bound": "string",
      "limit": 0,
      "json": true
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/get_scheduled_transaction";
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({
    "lower_bound": "string",
    "limit": 0,
    "json": true
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/get_scheduled_transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "lower_bound": "string",
      "limit": 0,
      "json": true
    }),
});

const data = await response.json();

import requests

payload = {
  "lower_bound": "string",
  "limit": 0,
  "json": True
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_scheduled_transaction', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_scheduled_transaction')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "lower_bound": "string",
    "limit": 0,
    "json": true
  }'

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

Request Body

{
  "lower_bound": "string",
  "limit": 0,
  "json": true
}

200

{
  "transactions": [
    {
      "expiration": "string",
      "ref_block_num": 0,
      "ref_block_prefix": 0,
      "max_net_usage_words": "string",
      "max_cpu_usage_ms": "string",
      "delay_sec": 0,
      "context_free_actions": [
        {
          "account": "string",
          "name": "string",
          "authorization": [
            {
              "actor": "string",
              "permission": "string"
            }
          ],
          "data": {},
          "hex_data": "string"
        }
      ],
      "actions": [
        {
          "account": "string",
          "name": "string",
          "authorization": [
            {
              "actor": "string",
              "permission": "string"
            }
          ],
          "data": {},
          "hex_data": "string"
        }
      ],
      "transaction_extensions": [
        [
          0
        ]
      ]
    }
  ]
}

POST

https://eos.nownodes.io/v1/chain/get_table_by_scope

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieves table scope

Body

application/json

codestringrequired

name of the contract to return table data for

tablestring

Filter results by table

lower_boundstring

Filters results to return the first element that is not less than provided value in set

upper_boundstring

Filters results to return the first element that is greater than provided value in set

limitinteger<int32>10

Limit number of results returned.

reversebooleanfalse

Reverse the order of returned results

show_payerbooleanfalse

Show RAM payer

Response

200OK

POST /get_table_by_scope

curl -X POST 'https://eos.nownodes.io/v1/chain/get_table_by_scope' \
  -H 'Content-Type: application/json' \
  -d '{
    "code": "string",
    "table": "string",
    "lower_bound": "string",
    "upper_bound": "string",
    "limit": 10,
    "reverse": false,
    "show_payer": false
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/get_table_by_scope', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "table": "string",
      "lower_bound": "string",
      "upper_bound": "string",
      "limit": 10,
      "reverse": false,
      "show_payer": false
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_table_by_scope')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "string",
    "table": "string",
    "lower_bound": "string",
    "upper_bound": "string",
    "limit": 10,
    "reverse": false,
    "show_payer": false
  }'

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

import requests

payload = {
  "code": "string",
  "table": "string",
  "lower_bound": "string",
  "upper_bound": "string",
  "limit": 10,
  "reverse": False,
  "show_payer": False
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_table_by_scope', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/get_table_by_scope', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "table": "string",
      "lower_bound": "string",
      "upper_bound": "string",
      "limit": 10,
      "reverse": false,
      "show_payer": false
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/get_table_by_scope";
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({
    "code": "string",
    "table": "string",
    "lower_bound": "string",
    "upper_bound": "string",
    "limit": 10,
    "reverse": false,
    "show_payer": false
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/get_table_by_scope', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "table": "string",
      "lower_bound": "string",
      "upper_bound": "string",
      "limit": 10,
      "reverse": false,
      "show_payer": false
    }),
});

const data = await response.json();

import requests

payload = {
  "code": "string",
  "table": "string",
  "lower_bound": "string",
  "upper_bound": "string",
  "limit": 10,
  "reverse": False,
  "show_payer": False
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_table_by_scope', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_table_by_scope')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "string",
    "table": "string",
    "lower_bound": "string",
    "upper_bound": "string",
    "limit": 10,
    "reverse": false,
    "show_payer": false
  }'

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

Request Body

{
  "code": "string",
  "table": "string",
  "lower_bound": "string",
  "upper_bound": "string",
  "limit": 10,
  "reverse": false,
  "show_payer": false
}

200

{
  "rows": [
    {
      "code": "string",
      "scope": "string",
      "table": "string",
      "payer": "string",
      "count": 0
    }
  ],
  "more": "string"
}

POST

https://eos.nownodes.io/v1/chain/get_table_rows

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an object containing rows from the specified table.

Body

application/json

codestringrequired

The name of the smart contract that controls the provided table

tablestringrequired

The name of the table to query

scopestringrequired

The account to which this data belongs

index_positionstring

Position of the index used, accepted parameters primary, secondary, tertiary, fourth, fifth, sixth, seventh, eighth, ninth , tenth

key_typestring

Type of key specified by index_position (for example - uint64_t or name)

encode_typestring

lower_boundstring

Filters results to return the first element that is not less than provided value in set

upper_boundstring

Filters results to return the first element that is greater than provided value in set

limitinteger<int32>10

Limit number of results returned.

reversebooleanfalse

Reverse the order of returned results

show_payerbooleanfalse

Show RAM payer

Response

200OK

POST /get_table_rows

curl -X POST 'https://eos.nownodes.io/v1/chain/get_table_rows' \
  -H 'Content-Type: application/json' \
  -d '{
    "code": "string",
    "table": "string",
    "scope": "string",
    "index_position": "string",
    "key_type": "string",
    "encode_type": "string",
    "lower_bound": "string",
    "upper_bound": "string",
    "limit": 10,
    "reverse": false,
    "show_payer": false
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/get_table_rows', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "table": "string",
      "scope": "string",
      "index_position": "string",
      "key_type": "string",
      "encode_type": "string",
      "lower_bound": "string",
      "upper_bound": "string",
      "limit": 10,
      "reverse": false,
      "show_payer": false
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_table_rows')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "string",
    "table": "string",
    "scope": "string",
    "index_position": "string",
    "key_type": "string",
    "encode_type": "string",
    "lower_bound": "string",
    "upper_bound": "string",
    "limit": 10,
    "reverse": false,
    "show_payer": false
  }'

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

import requests

payload = {
  "code": "string",
  "table": "string",
  "scope": "string",
  "index_position": "string",
  "key_type": "string",
  "encode_type": "string",
  "lower_bound": "string",
  "upper_bound": "string",
  "limit": 10,
  "reverse": False,
  "show_payer": False
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_table_rows', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/get_table_rows', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "table": "string",
      "scope": "string",
      "index_position": "string",
      "key_type": "string",
      "encode_type": "string",
      "lower_bound": "string",
      "upper_bound": "string",
      "limit": 10,
      "reverse": false,
      "show_payer": false
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/get_table_rows";
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({
    "code": "string",
    "table": "string",
    "scope": "string",
    "index_position": "string",
    "key_type": "string",
    "encode_type": "string",
    "lower_bound": "string",
    "upper_bound": "string",
    "limit": 10,
    "reverse": false,
    "show_payer": false
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/get_table_rows', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "table": "string",
      "scope": "string",
      "index_position": "string",
      "key_type": "string",
      "encode_type": "string",
      "lower_bound": "string",
      "upper_bound": "string",
      "limit": 10,
      "reverse": false,
      "show_payer": false
    }),
});

const data = await response.json();

import requests

payload = {
  "code": "string",
  "table": "string",
  "scope": "string",
  "index_position": "string",
  "key_type": "string",
  "encode_type": "string",
  "lower_bound": "string",
  "upper_bound": "string",
  "limit": 10,
  "reverse": False,
  "show_payer": False
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_table_rows', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_table_rows')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "string",
    "table": "string",
    "scope": "string",
    "index_position": "string",
    "key_type": "string",
    "encode_type": "string",
    "lower_bound": "string",
    "upper_bound": "string",
    "limit": 10,
    "reverse": false,
    "show_payer": false
  }'

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

Request Body

{
  "code": "string",
  "table": "string",
  "scope": "string",
  "index_position": "string",
  "key_type": "string",
  "encode_type": "string",
  "lower_bound": "string",
  "upper_bound": "string",
  "limit": 10,
  "reverse": false,
  "show_payer": false
}

200

{
  "rows": []
}

POST

https://eos.nownodes.io/v1/chain/get_kv_table_rows

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an object containing rows from the specified kv table.

Body

application/json

codestringrequired

The name of the smart contract that controls the provided kv table

tablestringrequired

The name of the kv table to query

index_namestringrequired

The name of primary or secondary index

encode_typestring

Encoding type to use for index_value, lower_bound, and upper_bound. Valid values are "bytes", "string", "name", "dec", or "hex"'. If not provided, the appropriate value based on the index_name's abi indicated type, for integers "dec" is the default. "bytes" are encoded as hexidecimal strings and can be used for any type of field. Example values for each type "bytes" => "0000000000000e1a", "string" => "Some value!", "name" => "eosio", "dec" => "3610", and "hex" => "e1a".

index_valuestring

Index value used for point query encoded as 'encode_type'. Cannot be used with either lower_bound or upper_bound.

lower_boundstring

Lower bound index value for ranged query. Query result includes rows specified with lower_bound. Cannot be used with index_value. If index_value and lower_bound are not provided, then lower_bound is defaulted to be the lowest value in the table for that index_name.

upper_boundstring

Upper bound index value for ranged query. Query result includes rows specified with upper_bound. Cannot be used with index_value. If index_value and upper_bound are not provided, then upper_bound is defaulted to be the highest value in the table for that index_name.

limitinteger<int32>

Limit number of results returned

reverseboolean

Reverse the order of returned results

show_payerboolean

Provide the ram payer for each row

Response

200OK

POST /get_kv_table_rows

curl -X POST 'https://eos.nownodes.io/v1/chain/get_kv_table_rows' \
  -H 'Content-Type: application/json' \
  -d '{
    "code": "string",
    "table": "string",
    "index_name": "string",
    "encode_type": "string",
    "index_value": "string",
    "lower_bound": "string",
    "upper_bound": "string",
    "limit": 0,
    "reverse": true,
    "show_payer": true
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/get_kv_table_rows', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "table": "string",
      "index_name": "string",
      "encode_type": "string",
      "index_value": "string",
      "lower_bound": "string",
      "upper_bound": "string",
      "limit": 0,
      "reverse": true,
      "show_payer": true
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_kv_table_rows')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "string",
    "table": "string",
    "index_name": "string",
    "encode_type": "string",
    "index_value": "string",
    "lower_bound": "string",
    "upper_bound": "string",
    "limit": 0,
    "reverse": true,
    "show_payer": true
  }'

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

import requests

payload = {
  "code": "string",
  "table": "string",
  "index_name": "string",
  "encode_type": "string",
  "index_value": "string",
  "lower_bound": "string",
  "upper_bound": "string",
  "limit": 0,
  "reverse": True,
  "show_payer": True
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_kv_table_rows', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/get_kv_table_rows', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "table": "string",
      "index_name": "string",
      "encode_type": "string",
      "index_value": "string",
      "lower_bound": "string",
      "upper_bound": "string",
      "limit": 0,
      "reverse": true,
      "show_payer": true
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/get_kv_table_rows";
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({
    "code": "string",
    "table": "string",
    "index_name": "string",
    "encode_type": "string",
    "index_value": "string",
    "lower_bound": "string",
    "upper_bound": "string",
    "limit": 0,
    "reverse": true,
    "show_payer": true
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/get_kv_table_rows', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "table": "string",
      "index_name": "string",
      "encode_type": "string",
      "index_value": "string",
      "lower_bound": "string",
      "upper_bound": "string",
      "limit": 0,
      "reverse": true,
      "show_payer": true
    }),
});

const data = await response.json();

import requests

payload = {
  "code": "string",
  "table": "string",
  "index_name": "string",
  "encode_type": "string",
  "index_value": "string",
  "lower_bound": "string",
  "upper_bound": "string",
  "limit": 0,
  "reverse": True,
  "show_payer": True
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_kv_table_rows', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_kv_table_rows')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "string",
    "table": "string",
    "index_name": "string",
    "encode_type": "string",
    "index_value": "string",
    "lower_bound": "string",
    "upper_bound": "string",
    "limit": 0,
    "reverse": true,
    "show_payer": true
  }'

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

Request Body

{
  "code": "string",
  "table": "string",
  "index_name": "string",
  "encode_type": "string",
  "index_value": "string",
  "lower_bound": "string",
  "upper_bound": "string",
  "limit": 0,
  "reverse": true,
  "show_payer": true
}

200

{
  "rows": [],
  "more": true,
  "next_key": "string",
  "next_key_bytes": "string"
}

POST

https://eos.nownodes.io/v1/chain/abi_json_to_bin

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an object containing the serialized action data.

Body

application/json

codestring | string | string | string

actionstring | string | string | string

argsobject

json object of the action parameters that will be serialized.

Response

200OK

POST /abi_json_to_bin

curl -X POST 'https://eos.nownodes.io/v1/chain/abi_json_to_bin' \
  -H 'Content-Type: application/json' \
  -d '{
    "code": "string",
    "action": "string",
    "args": {}
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/abi_json_to_bin', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "action": "string",
      "args": {}
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/abi_json_to_bin')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "string",
    "action": "string",
    "args": {}
  }'

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

import requests

payload = {
  "code": "string",
  "action": "string",
  "args": {}
}

response = requests.post('https://eos.nownodes.io/v1/chain/abi_json_to_bin', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/abi_json_to_bin', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "action": "string",
      "args": {}
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/abi_json_to_bin";
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({
    "code": "string",
    "action": "string",
    "args": {}
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/abi_json_to_bin', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "action": "string",
      "args": {}
    }),
});

const data = await response.json();

import requests

payload = {
  "code": "string",
  "action": "string",
  "args": {}
}

response = requests.post('https://eos.nownodes.io/v1/chain/abi_json_to_bin', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/abi_json_to_bin')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "string",
    "action": "string",
    "args": {}
  }'

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

Request Body

{
  "code": "string",
  "action": "string",
  "args": {}
}

200

{
  "binargs": "string"
}

POST

https://eos.nownodes.io/v1/chain/abi_bin_to_json

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an object containing the deserialized action data.

Body

application/json

codestring | string | string | stringrequired

actionstring | string | string | stringrequired

binargsbinargsrequired

Response

200OK

POST /abi_bin_to_json

curl -X POST 'https://eos.nownodes.io/v1/chain/abi_bin_to_json' \
  -H 'Content-Type: application/json' \
  -d '{
    "code": "string",
    "action": "string",
    "binargs": "string"
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/abi_bin_to_json', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "action": "string",
      "binargs": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/abi_bin_to_json')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "string",
    "action": "string",
    "binargs": "string"
  }'

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

import requests

payload = {
  "code": "string",
  "action": "string",
  "binargs": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/abi_bin_to_json', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/abi_bin_to_json', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "action": "string",
      "binargs": "string"
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/abi_bin_to_json";
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({
    "code": "string",
    "action": "string",
    "binargs": "string"
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/abi_bin_to_json', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "string",
      "action": "string",
      "binargs": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "code": "string",
  "action": "string",
  "binargs": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/abi_bin_to_json', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/abi_bin_to_json')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "string",
    "action": "string",
    "binargs": "string"
  }'

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

Request Body

{
  "code": "string",
  "action": "string",
  "binargs": "string"
}

200

"string"

POST

https://eos.nownodes.io/v1/chain/get_code

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an object containing the smart contract WASM code.

Body

application/json

account_namestring | string | string | stringrequired

code_as_wasminteger1required

This must be 1 (true)

Response

200OK

POST /get_code

curl -X POST 'https://eos.nownodes.io/v1/chain/get_code' \
  -H 'Content-Type: application/json' \
  -d '{
    "account_name": "string",
    "code_as_wasm": 1
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/get_code', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "account_name": "string",
      "code_as_wasm": 1
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_code')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "account_name": "string",
    "code_as_wasm": 1
  }'

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

import requests

payload = {
  "account_name": "string",
  "code_as_wasm": 1
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_code', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/get_code', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "account_name": "string",
      "code_as_wasm": 1
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/get_code";
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({
    "account_name": "string",
    "code_as_wasm": 1
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/get_code', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "account_name": "string",
      "code_as_wasm": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "account_name": "string",
  "code_as_wasm": 1
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_code', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_code')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "account_name": "string",
    "code_as_wasm": 1
  }'

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

Request Body

{
  "account_name": "string",
  "code_as_wasm": 1
}

200

{
  "name": "string",
  "code_hash": "string",
  "wast": "string",
  "wasm": "string",
  "abi": {
    "version": "string",
    "types": [
      {
        "new_type_name": "string",
        "type": "uint8"
      }
    ],
    "structs": [
      {
        "name": "string",
        "base": "string",
        "fields": [
          {
            "name": "string",
            "type": "uint8"
          }
        ]
      }
    ],
    "actions": [
      {
        "name": "string",
        "type": "string",
        "ricardian_contract": "string"
      }
    ],
    "tables": [
      {
        "name": "string",
        "index_type": "i64",
        "key_names": [
          "string"
        ],
        "key_types": [
          "uint64"
        ],
        "type": "string"
      }
    ],
    "abi_extensions": [
      [
        0
      ]
    ],
    "error_messages": [
      "string"
    ],
    "ricardian_clauses": [
      "string"
    ],
    "variants": [
      "string"
    ]
  }
}

POST

https://eos.nownodes.io/v1/chain/get_raw_abi

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an object containing the smart contract abi.

Body

application/json

account_namestring | string | string | stringrequired

Response

200OK

POST /get_raw_abi

curl -X POST 'https://eos.nownodes.io/v1/chain/get_raw_abi' \
  -H 'Content-Type: application/json' \
  -d '{
    "account_name": "string"
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/get_raw_abi', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "account_name": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_raw_abi')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "account_name": "string"
  }'

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

import requests

payload = {
  "account_name": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_raw_abi', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/get_raw_abi', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "account_name": "string"
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/get_raw_abi";
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({
    "account_name": "string"
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/get_raw_abi', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "account_name": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "account_name": "string"
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_raw_abi', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_raw_abi')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "account_name": "string"
  }'

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

Request Body

{
  "account_name": "string"
}

200

{
  "account_name": "string",
  "code_hash": "string",
  "abi": "string"
}

POST

https://eos.nownodes.io/v1/chain/get_activated_protocol_features

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retreives the activated protocol features for producer node

Body

application/json

lower_boundinteger

Lower bound

upper_boundinteger

Upper bound

limitinteger

The limit, default is 10

search_by_block_numboolean

Flag to indicate it is has to search by block number

reverseboolean

Flag to indicate it has to search in reverse

Response

200OK

POST /get_activated_protocol_features

curl -X POST 'https://eos.nownodes.io/v1/chain/get_activated_protocol_features' \
  -H 'Content-Type: application/json' \
  -d '{
    "lower_bound": 0,
    "upper_bound": 0,
    "limit": 0,
    "search_by_block_num": true,
    "reverse": true
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/get_activated_protocol_features', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "lower_bound": 0,
      "upper_bound": 0,
      "limit": 0,
      "search_by_block_num": true,
      "reverse": true
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_activated_protocol_features')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "lower_bound": 0,
    "upper_bound": 0,
    "limit": 0,
    "search_by_block_num": true,
    "reverse": true
  }'

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

import requests

payload = {
  "lower_bound": 0,
  "upper_bound": 0,
  "limit": 0,
  "search_by_block_num": True,
  "reverse": True
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_activated_protocol_features', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/get_activated_protocol_features', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "lower_bound": 0,
      "upper_bound": 0,
      "limit": 0,
      "search_by_block_num": true,
      "reverse": true
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/get_activated_protocol_features";
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({
    "lower_bound": 0,
    "upper_bound": 0,
    "limit": 0,
    "search_by_block_num": true,
    "reverse": true
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/get_activated_protocol_features', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "lower_bound": 0,
      "upper_bound": 0,
      "limit": 0,
      "search_by_block_num": true,
      "reverse": true
    }),
});

const data = await response.json();

import requests

payload = {
  "lower_bound": 0,
  "upper_bound": 0,
  "limit": 0,
  "search_by_block_num": True,
  "reverse": True
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_activated_protocol_features', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_activated_protocol_features')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "lower_bound": 0,
    "upper_bound": 0,
    "limit": 0,
    "search_by_block_num": true,
    "reverse": true
  }'

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

Request Body

{
  "lower_bound": 0,
  "upper_bound": 0,
  "limit": 0,
  "search_by_block_num": true,
  "reverse": true
}

200

{
  "activated_protocol_features": [
    "string"
  ],
  "more": 0
}

POST

https://eos.nownodes.io/v1/chain/get_accounts_by_authorizers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Given a set of account names and public keys, find all account permission authorities that are, in part or whole, satisfiable

Body

application/json

accountsArray<string | string | string | string | 1>

List of authorizing accounts and/or actor/permissions

Show child attributes

Any of

String representation of privileged EOSIO name type

string

String representation of basic EOSIO name type, must be 12 characters and contain only a-z and 0-5

string

String representation of EOSIO bid name type, 1-12 characters and only a-z and 0-5 are allowed

string

String representation of EOSIO name type

string

actorstring | string | string | stringrequired

permissionstring | string | string | stringrequired

keysArray<items>

List of authorizing keys

Response

200OK

POST /get_accounts_by_authorizers

curl -X POST 'https://eos.nownodes.io/v1/chain/get_accounts_by_authorizers' \
  -H 'Content-Type: application/json' \
  -d '{
    "accounts": [
      "string"
    ],
    "keys": [
      "string"
    ]
  }'

const response = await fetch('https://eos.nownodes.io/v1/chain/get_accounts_by_authorizers', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "accounts": [
        "string"
      ],
      "keys": [
        "string"
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_accounts_by_authorizers')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "accounts": [
      "string"
    ],
    "keys": [
      "string"
    ]
  }'

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

import requests

payload = {
  "accounts": [
    "string"
  ],
  "keys": [
    "string"
  ]
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_accounts_by_authorizers', json=payload)
data = response.json()

const response = await fetch('https://eos.nownodes.io/v1/chain/get_accounts_by_authorizers', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "accounts": [
        "string"
      ],
      "keys": [
        "string"
      ]
    }),
});

const data = await response.json();

const endpoint = "https://eos.nownodes.io/v1/chain/get_accounts_by_authorizers";
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({
    "accounts": [
      "string"
    ],
    "keys": [
      "string"
    ]
  });
console.log(result);

const response = await fetch('https://eos.nownodes.io/v1/chain/get_accounts_by_authorizers', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "accounts": [
        "string"
      ],
      "keys": [
        "string"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "accounts": [
    "string"
  ],
  "keys": [
    "string"
  ]
}

response = requests.post('https://eos.nownodes.io/v1/chain/get_accounts_by_authorizers', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://eos.nownodes.io/v1/chain/get_accounts_by_authorizers')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "accounts": [
      "string"
    ],
    "keys": [
      "string"
    ]
  }'

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

Request Body

{
  "accounts": [
    "string"
  ],
  "keys": [
    "string"
  ]
}

200

{
  "accounts": [
    {
      "account_name": "string",
      "permission_name": "string",
      "authorizer": "string",
      "weight": 0,
      "threshold": 0
    }
  ]
}

Documentation

How to migrate to NOWNodes

Authentication

Chain

Chain

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response