Meterest

v1.2.2

Base URL

https://meter.nownodes.io

RESTful API to access Meter.io

Project Home

Authentication

api-keyAuthapiKey

API Key: api-key in header

API Reference

Accounts

Access to account objects

Retrieve account detail

GET

https://meter.nownodes.io/accounts/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

includes balance, energy and hasCode, by account address. An account with hasCode be true is a contract.

Historical account detail can be queried by specifying revision query string.

Parameters

addressstring<bytes20>requiredpath

address of account

revisionstringquery

can be block number or ID. best block is assumed if omitted.

Response

200OK

Retrieve account detail

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

200

{
  "balance": "0x47ff1f90327aa0f8e",
  "energy": "0xcf624158d591398",
  "hasCode": false
}

Execute account code

POST

https://meter.nownodes.io/accounts/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

to simulate contract method call, without sending transaction to block chain.

It's useful to estimate gas usage and execution result of a clause.

Body

application/json

arguments and environment

valuestring

amount of token to be transferred

datastring

input data for contract call

gasinteger<uint64>

max allowed gas for execution

gasPricestring

absolute gas price

callerstring

caller address (msg.sender)

Parameters

addressstring<bytes20>requiredpath

address of account

revisionstringquery

can be block number or ID. best block is assumed if omitted.

Response

200OK

Execute account code

curl -X POST 'https://meter.nownodes.io/accounts/{address}' \
  -H 'Content-Type: application/json' \
  -d '{
    "value": "0xde0b6b3a7640000",
    "data": "0x5665436861696e2054686f72"
  }'

const response = await fetch('https://meter.nownodes.io/accounts/{address}', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "value": "0xde0b6b3a7640000",
      "data": "0x5665436861696e2054686f72"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/accounts/{address}')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "value": "0xde0b6b3a7640000",
    "data": "0x5665436861696e2054686f72"
  }'

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

import requests

payload = {
  "value": "0xde0b6b3a7640000",
  "data": "0x5665436861696e2054686f72"
}

response = requests.post('https://meter.nownodes.io/accounts/{address}', json=payload)
data = response.json()

const response = await fetch('https://meter.nownodes.io/accounts/{address}', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "value": "0xde0b6b3a7640000",
      "data": "0x5665436861696e2054686f72"
    }),
});

const data = await response.json();

const endpoint = "https://meter.nownodes.io/accounts/{address}";
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({
    "value": "0xde0b6b3a7640000",
    "data": "0x5665436861696e2054686f72"
  });
console.log(result);

const response = await fetch('https://meter.nownodes.io/accounts/{address}', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "value": "0xde0b6b3a7640000",
      "data": "0x5665436861696e2054686f72"
    }),
});

const data = await response.json();

import requests

payload = {
  "value": "0xde0b6b3a7640000",
  "data": "0x5665436861696e2054686f72"
}

response = requests.post('https://meter.nownodes.io/accounts/{address}', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/accounts/{address}')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "value": "0xde0b6b3a7640000",
    "data": "0x5665436861696e2054686f72"
  }'

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

Request Body

{
  "value": "0xde0b6b3a7640000",
  "data": "0x5665436861696e2054686f72"
}

200

{
  "data": "0x103556a73c10e38ffe2fc4aa50fc9d46ad0148f07e26417e117bd1ece9d948b5",
  "events": [
    {
      "address": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed",
      "topics": [
        "0x4de71f2d588aa8a1ea00fe8312d92966da424d9939a511fc0be81e65fad52af8"
      ],
      "data": "0x4de71f2d588aa8a1ea00fe8312d92966da424d9939a511fc0be81e65fad52af8"
    }
  ],
  "transfers": [
    {
      "sender": "0xdb4027477b2a8fe4c83c6dafe7f86678bb1b8a8d",
      "recipient": "0x5034aa590125b64023a0262112b98d72e3c8e40e",
      "amount": "0x47fdb3c3f456c0000"
    }
  ],
  "gasUsed": 21000,
  "reverted": false,
  "vmError": ""
}

Execute a batch of codes

POST

https://meter.nownodes.io/accounts/*

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

to simulate execution of a transaction.

Body

application/json

arguments and environment

clausesArray<Clause>

Show child attributes

tostring

recipient of clause, null for contract deployment (bytes32)

valuestring

hex form of token to be transferred

datastring

input data (bytes)

gasinteger<uint64>

max allowed gas for execution

gasPricestring

absolute gas price

callerstring

caller address (msg.sender)

Parameters

revisionstringquery

can be block number or ID. best block is assumed if omitted.

Response

200OK

Execute a batch of codes

curl -X POST 'https://meter.nownodes.io/accounts/*' \
  -H 'Content-Type: application/json' \
  -d '{
    "clauses": [
      {
        "to": "0x5034aa590125b64023a0262112b98d72e3c8e40e",
        "value": "0xde0b6b3a7640000",
        "data": "0x5665436861696e2054686f72"
      }
    ]
  }'

const response = await fetch('https://meter.nownodes.io/accounts/*', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "clauses": [
        {
          "to": "0x5034aa590125b64023a0262112b98d72e3c8e40e",
          "value": "0xde0b6b3a7640000",
          "data": "0x5665436861696e2054686f72"
        }
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/accounts/*')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "clauses": [
      {
        "to": "0x5034aa590125b64023a0262112b98d72e3c8e40e",
        "value": "0xde0b6b3a7640000",
        "data": "0x5665436861696e2054686f72"
      }
    ]
  }'

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

import requests

payload = {
  "clauses": [
    {
      "to": "0x5034aa590125b64023a0262112b98d72e3c8e40e",
      "value": "0xde0b6b3a7640000",
      "data": "0x5665436861696e2054686f72"
    }
  ]
}

response = requests.post('https://meter.nownodes.io/accounts/*', json=payload)
data = response.json()

const response = await fetch('https://meter.nownodes.io/accounts/*', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "clauses": [
        {
          "to": "0x5034aa590125b64023a0262112b98d72e3c8e40e",
          "value": "0xde0b6b3a7640000",
          "data": "0x5665436861696e2054686f72"
        }
      ]
    }),
});

const data = await response.json();

const endpoint = "https://meter.nownodes.io/accounts/*";
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({
    "clauses": [
      {
        "to": "0x5034aa590125b64023a0262112b98d72e3c8e40e",
        "value": "0xde0b6b3a7640000",
        "data": "0x5665436861696e2054686f72"
      }
    ]
  });
console.log(result);

const response = await fetch('https://meter.nownodes.io/accounts/*', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "clauses": [
        {
          "to": "0x5034aa590125b64023a0262112b98d72e3c8e40e",
          "value": "0xde0b6b3a7640000",
          "data": "0x5665436861696e2054686f72"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "clauses": [
    {
      "to": "0x5034aa590125b64023a0262112b98d72e3c8e40e",
      "value": "0xde0b6b3a7640000",
      "data": "0x5665436861696e2054686f72"
    }
  ]
}

response = requests.post('https://meter.nownodes.io/accounts/*', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/accounts/*')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "clauses": [
      {
        "to": "0x5034aa590125b64023a0262112b98d72e3c8e40e",
        "value": "0xde0b6b3a7640000",
        "data": "0x5665436861696e2054686f72"
      }
    ]
  }'

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

Request Body

{
  "clauses": [
    {
      "to": "0x5034aa590125b64023a0262112b98d72e3c8e40e",
      "value": "0xde0b6b3a7640000",
      "data": "0x5665436861696e2054686f72"
    }
  ]
}

200

[
  {
    "data": "0x103556a73c10e38ffe2fc4aa50fc9d46ad0148f07e26417e117bd1ece9d948b5",
    "events": [
      {
        "address": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed",
        "topics": [
          "0x4de71f2d588aa8a1ea00fe8312d92966da424d9939a511fc0be81e65fad52af8"
        ],
        "data": "0x4de71f2d588aa8a1ea00fe8312d92966da424d9939a511fc0be81e65fad52af8"
      }
    ],
    "transfers": [
      {
        "sender": "0xdb4027477b2a8fe4c83c6dafe7f86678bb1b8a8d",
        "recipient": "0x5034aa590125b64023a0262112b98d72e3c8e40e",
        "amount": "0x47fdb3c3f456c0000"
      }
    ],
    "gasUsed": 21000,
    "reverted": false,
    "vmError": ""
  }
]

Execute bytecodes

POST

https://meter.nownodes.io/accounts

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

to simulate contract deployment without sending transaction to block chain.

It's useful to estimate gas usage and contract deployment result of a clause.

TIPS:

data in request body is the bytecodes of a contract
data in response body is the runtime bytecodes assigned to account which the contract to be deployed

Body

application/json

arguments and environment

valuestring

amount of token to be transferred

datastring

input data for contract call

gasinteger<uint64>

max allowed gas for execution

gasPricestring

absolute gas price

callerstring

caller address (msg.sender)

Parameters

revisionstringquery

can be block number or ID. best block is assumed if omitted.

Response

200OK

Execute bytecodes

curl -X POST 'https://meter.nownodes.io/accounts' \
  -H 'Content-Type: application/json' \
  -d '{
    "value": "0xde0b6b3a7640000",
    "data": "0x5665436861696e2054686f72"
  }'

const response = await fetch('https://meter.nownodes.io/accounts', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "value": "0xde0b6b3a7640000",
      "data": "0x5665436861696e2054686f72"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/accounts')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "value": "0xde0b6b3a7640000",
    "data": "0x5665436861696e2054686f72"
  }'

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

import requests

payload = {
  "value": "0xde0b6b3a7640000",
  "data": "0x5665436861696e2054686f72"
}

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

const response = await fetch('https://meter.nownodes.io/accounts', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "value": "0xde0b6b3a7640000",
      "data": "0x5665436861696e2054686f72"
    }),
});

const data = await response.json();

const endpoint = "https://meter.nownodes.io/accounts";
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({
    "value": "0xde0b6b3a7640000",
    "data": "0x5665436861696e2054686f72"
  });
console.log(result);

const response = await fetch('https://meter.nownodes.io/accounts', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "value": "0xde0b6b3a7640000",
      "data": "0x5665436861696e2054686f72"
    }),
});

const data = await response.json();

import requests

payload = {
  "value": "0xde0b6b3a7640000",
  "data": "0x5665436861696e2054686f72"
}

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

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/accounts')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "value": "0xde0b6b3a7640000",
    "data": "0x5665436861696e2054686f72"
  }'

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

Request Body

{
  "value": "0xde0b6b3a7640000",
  "data": "0x5665436861696e2054686f72"
}

200

{
  "data": "0x103556a73c10e38ffe2fc4aa50fc9d46ad0148f07e26417e117bd1ece9d948b5",
  "events": [
    {
      "address": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed",
      "topics": [
        "0x4de71f2d588aa8a1ea00fe8312d92966da424d9939a511fc0be81e65fad52af8"
      ],
      "data": "0x4de71f2d588aa8a1ea00fe8312d92966da424d9939a511fc0be81e65fad52af8"
    }
  ],
  "transfers": [
    {
      "sender": "0xdb4027477b2a8fe4c83c6dafe7f86678bb1b8a8d",
      "recipient": "0x5034aa590125b64023a0262112b98d72e3c8e40e",
      "amount": "0x47fdb3c3f456c0000"
    }
  ],
  "gasUsed": 21000,
  "reverted": false,
  "vmError": ""
}

Retrieve account code

GET

https://meter.nownodes.io/accounts/{address}/code

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

if any. Here the code is runtime bytecodes.

Parameters

addressstring<bytes20>requiredpath

address of account

revisionstringquery

can be block number or ID. best block is assumed if omitted.

Response

200OK

Retrieve account code

curl -X GET 'https://meter.nownodes.io/accounts/{address}/code'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

200

{
  "code": "0x6060604052600080fd00a165627a7a72305820c23d3ae2dc86ad130561a2829d87c7cb8435365492bd1548eb7e7fc0f3632be90029"
}

Retrieve account storage value

GET

https://meter.nownodes.io/accounts/{address}/storage/{key}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

for given key.

Parameters

addressstring<bytes20>requiredpath

address of account

keystringrequiredpath

the key(position) to access account storage

revisionstringquery

can be block number or ID. best block is assumed if omitted.

Response

200OK

Retrieve account storage value

curl -X GET 'https://meter.nownodes.io/accounts/{address}/storage/{key}'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

const data = await response.json();

const endpoint = "https://meter.nownodes.io/accounts/{address}/storage/{key}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

200

{
  "value": "0x0000000000000000000000000000000000000000000000000000000000000001"
}

Transactions

Access to transactions

Retrieve transaction

GET

https://meter.nownodes.io/transactions/{id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

by ID.

Parameters

idstringrequiredpath

ID of transaction

rawbooleanquery

whether retrieve a raw transaction.

headstringquery

ID of head block. best block is assumed if omitted

Response

200OK

Retrieve transaction

curl -X GET 'https://meter.nownodes.io/transactions/{id}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/transactions/{id}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://meter.nownodes.io/transactions/{id}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://meter.nownodes.io/transactions/{id}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://meter.nownodes.io/transactions/{id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/transactions/{id}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "id": "0x4de71f2d588aa8a1ea00fe8312d92966da424d9939a511fc0be81e65fad52af8",
  "chainTag": 1,
  "blockRef": "0x00000001511fc0be",
  "expiration": 30,
  "clauses": [],
  "gasPriceCoef": 128,
  "gas": 21000,
  "origin": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed",
  "nonce": "0xd92966da424d9939",
  "dependsOn": null,
  "size": 180,
  "meta": {
    "blockID": "0x00000001c458949985a6d86b7139690b8811dd3b4647c02d4f41cdefb7d32327",
    "blockNumber": 1,
    "blockTimestamp": 1523156271
  }
}

Retrieve transaction receipt

GET

https://meter.nownodes.io/transactions/{id}/receipt

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

by ID.

Parameters

idstringrequiredpath

ID of transaction

headstringquery

ID of head block. best block is assumed if omitted

Response

200OK

Retrieve transaction receipt

curl -X GET 'https://meter.nownodes.io/transactions/{id}/receipt'

const response = await fetch('https://meter.nownodes.io/transactions/{id}/receipt', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/transactions/{id}/receipt')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://meter.nownodes.io/transactions/{id}/receipt')
data = response.json()

const response = await fetch('https://meter.nownodes.io/transactions/{id}/receipt', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://meter.nownodes.io/transactions/{id}/receipt";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://meter.nownodes.io/transactions/{id}/receipt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://meter.nownodes.io/transactions/{id}/receipt')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/transactions/{id}/receipt')
request = Net::HTTP::Get.new(uri)

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

200

{
  "gasUsed": 21000,
  "gasPayer": "0xdb4027477b2a8fe4c83c6dafe7f86678bb1b8a8d",
  "paid": "0x1236efcbcbb340000",
  "reward": "0x576e189f04f60000",
  "reverted": false,
  "outputs": [
    {
      "contractAddress": null,
      "events": [
        {
          "address": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed",
          "topics": [
            "0x4de71f2d588aa8a1ea00fe8312d92966da424d9939a511fc0be81e65fad52af8"
          ],
          "data": "0x4de71f2d588aa8a1ea00fe8312d92966da424d9939a511fc0be81e65fad52af8"
        }
      ],
      "transfers": [
        {
          "sender": "0xdb4027477b2a8fe4c83c6dafe7f86678bb1b8a8d",
          "recipient": "0x5034aa590125b64023a0262112b98d72e3c8e40e",
          "amount": "0x47fdb3c3f456c0000"
        }
      ]
    }
  ],
  "meta": {
    "blockID": "0x0004f6cc88bb4626a92907718e82f255b8fa511453a78e8797eb8cea3393b215",
    "blockNumber": 325324,
    "blockTimestamp": 1533267900,
    "txID": "0x284bba50ef777889ff1a367ed0b38d5e5626714477c40de38d71cedd6f9fa477",
    "txOrigin": "0xdb4027477b2a8fe4c83c6dafe7f86678bb1b8a8d"
  }
}

Commit transaction

POST

https://meter.nownodes.io/transactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

in raw or structured format. If no signature in structured format, signingHash is returned in response body.

Body

application/json

One of

rawstring

hex form of encoded transaction

chainTaginteger<uint8>

last byte of genesis block ID

blockRefstring

8 bytes prefix of some block ID

expirationinteger<uint32>

expiration relative to blockRef, in unit block

clausesArray<Clause>

Show child attributes

tostring

recipient of clause, null for contract deployment (bytes32)

valuestring

hex form of token to be transferred

datastring

input data (bytes)

gasPriceCoefinteger<uint8>

coefficient used to calculate the final gas price

gasinteger<uint64>

max amount of gas can be consumed to execute this transaction

dependsOnstring<bytes32>

ID of the transaction on which the current transaction depends on. can be null.

noncestring

signaturestring

signature hex string

chainTaginteger<uint8>

last byte of genesis block ID

blockRefstring

8 bytes prefix of some block ID

expirationinteger<uint32>

expiration relative to blockRef, in unit block

clausesArray<Clause>

Show child attributes

tostring

recipient of clause, null for contract deployment (bytes32)

valuestring

hex form of token to be transferred

datastring

input data (bytes)

gasPriceCoefinteger<uint8>

coefficient used to calculate the final gas price

gasinteger<uint64>

max amount of gas can be consumed to execute this transaction

dependsOnstring<bytes32>

ID of the transaction on which the current transaction depends on. can be null.

noncestring

Response

200OK

Commit transaction

curl -X POST 'https://meter.nownodes.io/transactions' \
  -H 'Content-Type: application/json' \
  -d '{
    "raw": "0xf86981ba800adad994000000000000000000000000000000000000746f82271080018252088001c0b8414792c9439594098323900e6470742cd877ec9f9906bca05510e421f3b013ed221324e77ca10d3466b32b1800c72e12719b213f1d4c370305399dd27af962626400"
  }'

const response = await fetch('https://meter.nownodes.io/transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "raw": "0xf86981ba800adad994000000000000000000000000000000000000746f82271080018252088001c0b8414792c9439594098323900e6470742cd877ec9f9906bca05510e421f3b013ed221324e77ca10d3466b32b1800c72e12719b213f1d4c370305399dd27af962626400"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/transactions')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "raw": "0xf86981ba800adad994000000000000000000000000000000000000746f82271080018252088001c0b8414792c9439594098323900e6470742cd877ec9f9906bca05510e421f3b013ed221324e77ca10d3466b32b1800c72e12719b213f1d4c370305399dd27af962626400"
  }'

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

import requests

payload = {
  "raw": "0xf86981ba800adad994000000000000000000000000000000000000746f82271080018252088001c0b8414792c9439594098323900e6470742cd877ec9f9906bca05510e421f3b013ed221324e77ca10d3466b32b1800c72e12719b213f1d4c370305399dd27af962626400"
}

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

const response = await fetch('https://meter.nownodes.io/transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "raw": "0xf86981ba800adad994000000000000000000000000000000000000746f82271080018252088001c0b8414792c9439594098323900e6470742cd877ec9f9906bca05510e421f3b013ed221324e77ca10d3466b32b1800c72e12719b213f1d4c370305399dd27af962626400"
    }),
});

const data = await response.json();

const endpoint = "https://meter.nownodes.io/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({
    "raw": "0xf86981ba800adad994000000000000000000000000000000000000746f82271080018252088001c0b8414792c9439594098323900e6470742cd877ec9f9906bca05510e421f3b013ed221324e77ca10d3466b32b1800c72e12719b213f1d4c370305399dd27af962626400"
  });
console.log(result);

const response = await fetch('https://meter.nownodes.io/transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "raw": "0xf86981ba800adad994000000000000000000000000000000000000746f82271080018252088001c0b8414792c9439594098323900e6470742cd877ec9f9906bca05510e421f3b013ed221324e77ca10d3466b32b1800c72e12719b213f1d4c370305399dd27af962626400"
    }),
});

const data = await response.json();

import requests

payload = {
  "raw": "0xf86981ba800adad994000000000000000000000000000000000000746f82271080018252088001c0b8414792c9439594098323900e6470742cd877ec9f9906bca05510e421f3b013ed221324e77ca10d3466b32b1800c72e12719b213f1d4c370305399dd27af962626400"
}

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

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/transactions')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "raw": "0xf86981ba800adad994000000000000000000000000000000000000746f82271080018252088001c0b8414792c9439594098323900e6470742cd877ec9f9906bca05510e421f3b013ed221324e77ca10d3466b32b1800c72e12719b213f1d4c370305399dd27af962626400"
  }'

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

Request Body

{
  "raw": "0xf86981ba800adad994000000000000000000000000000000000000746f82271080018252088001c0b8414792c9439594098323900e6470742cd877ec9f9906bca05510e421f3b013ed221324e77ca10d3466b32b1800c72e12719b213f1d4c370305399dd27af962626400"
}

200

{
  "id": "0x4de71f2d588aa8a1ea00fe8312d92966da424d9939a511fc0be81e65fad52af8"
}

Blocks

Access to blocks

Retrieve block

GET

https://meter.nownodes.io/blocks/{revision}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

by ID or number, or 'best' for latest block.

Parameters

revisionstringrequiredpath

block ID or number, or 'best' stands for latest block

Response

200OK

Retrieve block

curl -X GET 'https://meter.nownodes.io/blocks/{revision}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/blocks/{revision}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://meter.nownodes.io/blocks/{revision}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://meter.nownodes.io/blocks/{revision}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://meter.nownodes.io/blocks/{revision}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/blocks/{revision}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "number": 325324,
  "id": "0x0004f6cc88bb4626a92907718e82f255b8fa511453a78e8797eb8cea3393b215",
  "size": 373,
  "parentID": "0x0004f6cb730dbd90fed09d165bfdf33cc0eed47ec068938f6ee7b7c12a4ea98d",
  "timestamp": 1533267900,
  "gasLimit": 11253579,
  "beneficiary": "0xb4094c25f86d628fdd571afc4077f0d0196afb48",
  "gasUsed": 21000,
  "totalScore": 1029988,
  "txsRoot": "0x89dfd9fcd10c9e53d68592cf8b540b280b72d381b868523223992f3e09a806bb",
  "stateRoot": "0x86bcc6d214bc9d8d0dedba1012a63c8317d19ce97f60c8a2ef5c59bbd40d4261",
  "receiptsRoot": "0x15787e2533c470e8a688e6cd17a1ee12d8457778d5f82d2c109e2d6226d8e54e",
  "signer": "0xab7b27fc9e7d29f9f2e5bd361747a5515d0cc2d1",
  "transactions": [
    "0x284bba50ef777889ff1a367ed0b38d5e5626714477c40de38d71cedd6f9fa477"
  ],
  "isTrunk": true
}

Logs

Access to event & transfer logs

Filter event logs

POST

https://meter.nownodes.io/logs/event

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Event logs are produced by OP_LOG in EVM.

Body

application/json

rangeFilterRange

defines the range to filter in. e.g.

Copied!

{
  "range": {
    "unit": "block",
    "from": 10,
    "to": 1000
  }
}

refers to the range from block 10 to block 1000. null stands for the full range.

Show child attributes

unitstringblocktime

defines the unit of from and to. block means block number, time means block timestamp, default to block.

frominteger<uint64>

tointeger<uint64>

optionsFilterOptions

pass these parameters if you need filtered results paged. e.g.

Copied!

{
  "options": {
    "offset": 0,
    "limit": 10   
  }
}

the above refers that page offset is 0, and the page size is 10. pass options null if you don't need to demand paging.

Show child attributes

offsetinteger

offset in matched record set

limitinteger

limit of records to output

criteriaSetArray<EventCriteria>

Show child attributes

addressstring

address of event emitter

topic0string

topic1string

topic2string

topic3string

topic4string

orderstringascdesc

order of filters, defaults to asc

Response

200OK

Filter event logs

curl -X POST 'https://meter.nownodes.io/logs/event' \
  -H 'Content-Type: application/json' \
  -d '{
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "criteriaSet": [
      {
        "address": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
      }
    ],
    "order": "asc"
  }'

const response = await fetch('https://meter.nownodes.io/logs/event', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "range": {
        "unit": "block",
        "from": 0,
        "to": 100000
      },
      "options": {
        "offset": 0,
        "limit": 10
      },
      "criteriaSet": [
        {
          "address": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
        }
      ],
      "order": "asc"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/logs/event')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "criteriaSet": [
      {
        "address": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
      }
    ],
    "order": "asc"
  }'

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

import requests

payload = {
  "range": {
    "unit": "block",
    "from": 0,
    "to": 100000
  },
  "options": {
    "offset": 0,
    "limit": 10
  },
  "criteriaSet": [
    {
      "address": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
    }
  ],
  "order": "asc"
}

response = requests.post('https://meter.nownodes.io/logs/event', json=payload)
data = response.json()

const response = await fetch('https://meter.nownodes.io/logs/event', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "range": {
        "unit": "block",
        "from": 0,
        "to": 100000
      },
      "options": {
        "offset": 0,
        "limit": 10
      },
      "criteriaSet": [
        {
          "address": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
        }
      ],
      "order": "asc"
    }),
});

const data = await response.json();

const endpoint = "https://meter.nownodes.io/logs/event";
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({
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "criteriaSet": [
      {
        "address": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
      }
    ],
    "order": "asc"
  });
console.log(result);

const response = await fetch('https://meter.nownodes.io/logs/event', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "range": {
        "unit": "block",
        "from": 0,
        "to": 100000
      },
      "options": {
        "offset": 0,
        "limit": 10
      },
      "criteriaSet": [
        {
          "address": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
        }
      ],
      "order": "asc"
    }),
});

const data = await response.json();

import requests

payload = {
  "range": {
    "unit": "block",
    "from": 0,
    "to": 100000
  },
  "options": {
    "offset": 0,
    "limit": 10
  },
  "criteriaSet": [
    {
      "address": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
    }
  ],
  "order": "asc"
}

response = requests.post('https://meter.nownodes.io/logs/event', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/logs/event')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "criteriaSet": [
      {
        "address": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
      }
    ],
    "order": "asc"
  }'

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

Request Body

{
  "range": {
    "unit": "block",
    "from": 0,
    "to": 100000
  },
  "options": {
    "offset": 0,
    "limit": 10
  },
  "criteriaSet": [
    {
      "address": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
    }
  ],
  "order": "asc"
}

200

[
  {
    "address": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed",
    "topics": [
      "0x4de71f2d588aa8a1ea00fe8312d92966da424d9939a511fc0be81e65fad52af8"
    ],
    "data": "0x4de71f2d588aa8a1ea00fe8312d92966da424d9939a511fc0be81e65fad52af8",
    "meta": {
      "blockID": "0x0004f6cc88bb4626a92907718e82f255b8fa511453a78e8797eb8cea3393b215",
      "blockNumber": 325324,
      "blockTimestamp": 1533267900,
      "txID": "0x284bba50ef777889ff1a367ed0b38d5e5626714477c40de38d71cedd6f9fa477",
      "txOrigin": "0xdb4027477b2a8fe4c83c6dafe7f86678bb1b8a8d"
    }
  }
]

Filter transfer logs

POST

https://meter.nownodes.io/logs/transfer

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Transfer logs are recorded on MTRG transferring.

Body

application/json

rangeFilterRange

defines the range to filter in. e.g.

Copied!

{
  "range": {
    "unit": "block",
    "from": 10,
    "to": 1000
  }
}

refers to the range from block 10 to block 1000. null stands for the full range.

Show child attributes

unitstringblocktime

defines the unit of from and to. block means block number, time means block timestamp, default to block.

frominteger<uint64>

tointeger<uint64>

optionsFilterOptions

pass these parameters if you need filtered results paged. e.g.

Copied!

{
  "options": {
    "offset": 0,
    "limit": 10   
  }
}

the above refers that page offset is 0, and the page size is 10. pass options null if you don't need to demand paging.

Show child attributes

offsetinteger

offset in matched record set

limitinteger

limit of records to output

criteriaSetArray<TransferCriteria>

Show child attributes

txOriginstring

senderstring

recipientstring

orderstringascdesc

order of filters, defaults to asc

Response

200OK

Filter transfer logs

curl -X POST 'https://meter.nownodes.io/logs/transfer' \
  -H 'Content-Type: application/json' \
  -d '{
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "criteriaSet": [
      {
        "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
      }
    ],
    "order": "asc"
  }'

const response = await fetch('https://meter.nownodes.io/logs/transfer', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "range": {
        "unit": "block",
        "from": 0,
        "to": 100000
      },
      "options": {
        "offset": 0,
        "limit": 10
      },
      "criteriaSet": [
        {
          "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
        }
      ],
      "order": "asc"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/logs/transfer')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "criteriaSet": [
      {
        "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
      }
    ],
    "order": "asc"
  }'

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

import requests

payload = {
  "range": {
    "unit": "block",
    "from": 0,
    "to": 100000
  },
  "options": {
    "offset": 0,
    "limit": 10
  },
  "criteriaSet": [
    {
      "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
    }
  ],
  "order": "asc"
}

response = requests.post('https://meter.nownodes.io/logs/transfer', json=payload)
data = response.json()

const response = await fetch('https://meter.nownodes.io/logs/transfer', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "range": {
        "unit": "block",
        "from": 0,
        "to": 100000
      },
      "options": {
        "offset": 0,
        "limit": 10
      },
      "criteriaSet": [
        {
          "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
        }
      ],
      "order": "asc"
    }),
});

const data = await response.json();

const endpoint = "https://meter.nownodes.io/logs/transfer";
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({
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "criteriaSet": [
      {
        "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
      }
    ],
    "order": "asc"
  });
console.log(result);

const response = await fetch('https://meter.nownodes.io/logs/transfer', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "range": {
        "unit": "block",
        "from": 0,
        "to": 100000
      },
      "options": {
        "offset": 0,
        "limit": 10
      },
      "criteriaSet": [
        {
          "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
        }
      ],
      "order": "asc"
    }),
});

const data = await response.json();

import requests

payload = {
  "range": {
    "unit": "block",
    "from": 0,
    "to": 100000
  },
  "options": {
    "offset": 0,
    "limit": 10
  },
  "criteriaSet": [
    {
      "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
    }
  ],
  "order": "asc"
}

response = requests.post('https://meter.nownodes.io/logs/transfer', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/logs/transfer')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "criteriaSet": [
      {
        "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
      }
    ],
    "order": "asc"
  }'

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

Request Body

{
  "range": {
    "unit": "block",
    "from": 0,
    "to": 100000
  },
  "options": {
    "offset": 0,
    "limit": 10
  },
  "criteriaSet": [
    {
      "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
    }
  ],
  "order": "asc"
}

200

[
  {
    "sender": "0xdb4027477b2a8fe4c83c6dafe7f86678bb1b8a8d",
    "recipient": "0x5034aa590125b64023a0262112b98d72e3c8e40e",
    "amount": "0x47fdb3c3f456c0000",
    "meta": {
      "blockID": "0x0004f6cc88bb4626a92907718e82f255b8fa511453a78e8797eb8cea3393b215",
      "blockNumber": 325324,
      "blockTimestamp": 1533267900,
      "txID": "0x284bba50ef777889ff1a367ed0b38d5e5626714477c40de38d71cedd6f9fa477",
      "txOrigin": "0xdb4027477b2a8fe4c83c6dafe7f86678bb1b8a8d"
    }
  }
]

Filter event logs

POST

https://meter.nownodes.io/logs/events

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Event logs are produced by OP_LOG in EVM.

Body

application/json

event filter criteria

rangeFilterRange

defines the range to filter in. e.g.

Copied!

{
  "range": {
    "unit": "block",
    "from": 10,
    "to": 1000
  }
}

refers to the range from block 10 to block 1000. null stands for the full range.

Show child attributes

unitstringblocktime

defines the unit of from and to. block means block number, time means block timestamp, default to block.

frominteger<uint64>

tointeger<uint64>

optionsFilterOptions

pass these parameters if you need filtered results paged. e.g.

Copied!

{
  "options": {
    "offset": 0,
    "limit": 10   
  }
}

the above refers that page offset is 0, and the page size is 10. pass options null if you don't need to demand paging.

Show child attributes

offsetinteger

offset in matched record set

limitinteger

limit of records to output

topicSetsArray<TopicSetLegacy>

Show child attributes

topic0string

topic1string

topic2string

topic3string

topic4string

Parameters

orderstringascdescquery

order of filters, defaults to asc

addressstringquery

address of account which is the events emitter

Response

200OK

Filter event logs

curl -X POST 'https://meter.nownodes.io/logs/events' \
  -H 'Content-Type: application/json' \
  -d '{
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "topicSets": [
      {
        "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
      }
    ]
  }'

const response = await fetch('https://meter.nownodes.io/logs/events', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "range": {
        "unit": "block",
        "from": 0,
        "to": 100000
      },
      "options": {
        "offset": 0,
        "limit": 10
      },
      "topicSets": [
        {
          "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
        }
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/logs/events')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "topicSets": [
      {
        "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
      }
    ]
  }'

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

import requests

payload = {
  "range": {
    "unit": "block",
    "from": 0,
    "to": 100000
  },
  "options": {
    "offset": 0,
    "limit": 10
  },
  "topicSets": [
    {
      "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
    }
  ]
}

response = requests.post('https://meter.nownodes.io/logs/events', json=payload)
data = response.json()

const response = await fetch('https://meter.nownodes.io/logs/events', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "range": {
        "unit": "block",
        "from": 0,
        "to": 100000
      },
      "options": {
        "offset": 0,
        "limit": 10
      },
      "topicSets": [
        {
          "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
        }
      ]
    }),
});

const data = await response.json();

const endpoint = "https://meter.nownodes.io/logs/events";
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({
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "topicSets": [
      {
        "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
      }
    ]
  });
console.log(result);

const response = await fetch('https://meter.nownodes.io/logs/events', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "range": {
        "unit": "block",
        "from": 0,
        "to": 100000
      },
      "options": {
        "offset": 0,
        "limit": 10
      },
      "topicSets": [
        {
          "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "range": {
    "unit": "block",
    "from": 0,
    "to": 100000
  },
  "options": {
    "offset": 0,
    "limit": 10
  },
  "topicSets": [
    {
      "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
    }
  ]
}

response = requests.post('https://meter.nownodes.io/logs/events', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/logs/events')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "topicSets": [
      {
        "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
      }
    ]
  }'

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

Request Body

{
  "range": {
    "unit": "block",
    "from": 0,
    "to": 100000
  },
  "options": {
    "offset": 0,
    "limit": 10
  },
  "topicSets": [
    {
      "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
    }
  ]
}

200

[
  {
    "address": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed",
    "topics": [
      "0x4de71f2d588aa8a1ea00fe8312d92966da424d9939a511fc0be81e65fad52af8"
    ],
    "data": "0x4de71f2d588aa8a1ea00fe8312d92966da424d9939a511fc0be81e65fad52af8",
    "meta": {
      "blockID": "0x0004f6cc88bb4626a92907718e82f255b8fa511453a78e8797eb8cea3393b215",
      "blockNumber": 325324,
      "blockTimestamp": 1533267900,
      "txID": "0x284bba50ef777889ff1a367ed0b38d5e5626714477c40de38d71cedd6f9fa477",
      "txOrigin": "0xdb4027477b2a8fe4c83c6dafe7f86678bb1b8a8d"
    }
  }
]

Filter transfer logs

POST

https://meter.nownodes.io/logs/transfers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Transfer logs are recorded on MTR transferring.

Body

application/json

transfer log filter criteria

rangeFilterRange

defines the range to filter in. e.g.

Copied!

{
  "range": {
    "unit": "block",
    "from": 10,
    "to": 1000
  }
}

refers to the range from block 10 to block 1000. null stands for the full range.

Show child attributes

unitstringblocktime

defines the unit of from and to. block means block number, time means block timestamp, default to block.

frominteger<uint64>

tointeger<uint64>

optionsFilterOptions

pass these parameters if you need filtered results paged. e.g.

Copied!

{
  "options": {
    "offset": 0,
    "limit": 10   
  }
}

the above refers that page offset is 0, and the page size is 10. pass options null if you don't need to demand paging.

Show child attributes

offsetinteger

offset in matched record set

limitinteger

limit of records to output

addressSetsArray<AddressSetLegacy>

Show child attributes

txOriginstring

senderstring

recipientstring

Parameters

orderstringascdescquery

order of filters, defaults to asc

Response

200OK

Filter transfer logs

curl -X POST 'https://meter.nownodes.io/logs/transfers' \
  -H 'Content-Type: application/json' \
  -d '{
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "addressSets": [
      {
        "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
      }
    ]
  }'

const response = await fetch('https://meter.nownodes.io/logs/transfers', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "range": {
        "unit": "block",
        "from": 0,
        "to": 100000
      },
      "options": {
        "offset": 0,
        "limit": 10
      },
      "addressSets": [
        {
          "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
        }
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/logs/transfers')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "addressSets": [
      {
        "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
      }
    ]
  }'

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

import requests

payload = {
  "range": {
    "unit": "block",
    "from": 0,
    "to": 100000
  },
  "options": {
    "offset": 0,
    "limit": 10
  },
  "addressSets": [
    {
      "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
    }
  ]
}

response = requests.post('https://meter.nownodes.io/logs/transfers', json=payload)
data = response.json()

const response = await fetch('https://meter.nownodes.io/logs/transfers', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "range": {
        "unit": "block",
        "from": 0,
        "to": 100000
      },
      "options": {
        "offset": 0,
        "limit": 10
      },
      "addressSets": [
        {
          "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
        }
      ]
    }),
});

const data = await response.json();

const endpoint = "https://meter.nownodes.io/logs/transfers";
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({
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "addressSets": [
      {
        "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
      }
    ]
  });
console.log(result);

const response = await fetch('https://meter.nownodes.io/logs/transfers', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "range": {
        "unit": "block",
        "from": 0,
        "to": 100000
      },
      "options": {
        "offset": 0,
        "limit": 10
      },
      "addressSets": [
        {
          "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "range": {
    "unit": "block",
    "from": 0,
    "to": 100000
  },
  "options": {
    "offset": 0,
    "limit": 10
  },
  "addressSets": [
    {
      "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
    }
  ]
}

response = requests.post('https://meter.nownodes.io/logs/transfers', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/logs/transfers')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "addressSets": [
      {
        "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
      }
    ]
  }'

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

Request Body

{
  "range": {
    "unit": "block",
    "from": 0,
    "to": 100000
  },
  "options": {
    "offset": 0,
    "limit": 10
  },
  "addressSets": [
    {
      "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
    }
  ]
}

200

[
  {
    "sender": "0xdb4027477b2a8fe4c83c6dafe7f86678bb1b8a8d",
    "recipient": "0x5034aa590125b64023a0262112b98d72e3c8e40e",
    "amount": "0x47fdb3c3f456c0000",
    "meta": {
      "blockID": "0x0004f6cc88bb4626a92907718e82f255b8fa511453a78e8797eb8cea3393b215",
      "blockNumber": 325324,
      "blockTimestamp": 1533267900,
      "txID": "0x284bba50ef777889ff1a367ed0b38d5e5626714477c40de38d71cedd6f9fa477",
      "txOrigin": "0xdb4027477b2a8fe4c83c6dafe7f86678bb1b8a8d"
    }
  }
]

Filter event logs

POST

https://meter.nownodes.io/events

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

event filter criteria

rangeFilterRange

defines the range to filter in. e.g.

Copied!

{
  "range": {
    "unit": "block",
    "from": 10,
    "to": 1000
  }
}

refers to the range from block 10 to block 1000. null stands for the full range.

Show child attributes

unitstringblocktime

defines the unit of from and to. block means block number, time means block timestamp, default to block.

frominteger<uint64>

tointeger<uint64>

optionsFilterOptions

pass these parameters if you need filtered results paged. e.g.

Copied!

{
  "options": {
    "offset": 0,
    "limit": 10   
  }
}

the above refers that page offset is 0, and the page size is 10. pass options null if you don't need to demand paging.

Show child attributes

offsetinteger

offset in matched record set

limitinteger

limit of records to output

topicSetsArray<TopicSetLegacy>

Show child attributes

topic0string

topic1string

topic2string

topic3string

topic4string

Parameters

orderstringascdescquery

order of filters, defaults to asc

addressstringquery

address of account which is the events emitter

Response

200OK

Filter event logs

curl -X POST 'https://meter.nownodes.io/events' \
  -H 'Content-Type: application/json' \
  -d '{
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "topicSets": [
      {
        "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
      }
    ]
  }'

const response = await fetch('https://meter.nownodes.io/events', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "range": {
        "unit": "block",
        "from": 0,
        "to": 100000
      },
      "options": {
        "offset": 0,
        "limit": 10
      },
      "topicSets": [
        {
          "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
        }
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/events')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "topicSets": [
      {
        "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
      }
    ]
  }'

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

import requests

payload = {
  "range": {
    "unit": "block",
    "from": 0,
    "to": 100000
  },
  "options": {
    "offset": 0,
    "limit": 10
  },
  "topicSets": [
    {
      "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
    }
  ]
}

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

const response = await fetch('https://meter.nownodes.io/events', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "range": {
        "unit": "block",
        "from": 0,
        "to": 100000
      },
      "options": {
        "offset": 0,
        "limit": 10
      },
      "topicSets": [
        {
          "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
        }
      ]
    }),
});

const data = await response.json();

const endpoint = "https://meter.nownodes.io/events";
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({
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "topicSets": [
      {
        "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
      }
    ]
  });
console.log(result);

const response = await fetch('https://meter.nownodes.io/events', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "range": {
        "unit": "block",
        "from": 0,
        "to": 100000
      },
      "options": {
        "offset": 0,
        "limit": 10
      },
      "topicSets": [
        {
          "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "range": {
    "unit": "block",
    "from": 0,
    "to": 100000
  },
  "options": {
    "offset": 0,
    "limit": 10
  },
  "topicSets": [
    {
      "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
    }
  ]
}

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

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/events')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "topicSets": [
      {
        "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
      }
    ]
  }'

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

Request Body

{
  "range": {
    "unit": "block",
    "from": 0,
    "to": 100000
  },
  "options": {
    "offset": 0,
    "limit": 10
  },
  "topicSets": [
    {
      "topic0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
    }
  ]
}

200

[
  {
    "address": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed",
    "topics": [
      "0x4de71f2d588aa8a1ea00fe8312d92966da424d9939a511fc0be81e65fad52af8"
    ],
    "data": "0x4de71f2d588aa8a1ea00fe8312d92966da424d9939a511fc0be81e65fad52af8",
    "meta": {
      "blockID": "0x0004f6cc88bb4626a92907718e82f255b8fa511453a78e8797eb8cea3393b215",
      "blockNumber": 325324,
      "blockTimestamp": 1533267900,
      "txID": "0x284bba50ef777889ff1a367ed0b38d5e5626714477c40de38d71cedd6f9fa477",
      "txOrigin": "0xdb4027477b2a8fe4c83c6dafe7f86678bb1b8a8d"
    }
  }
]

Filter transfer logs

POST

https://meter.nownodes.io/transfers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

transfer log filter criteria

rangeFilterRange

defines the range to filter in. e.g.

Copied!

{
  "range": {
    "unit": "block",
    "from": 10,
    "to": 1000
  }
}

refers to the range from block 10 to block 1000. null stands for the full range.

Show child attributes

unitstringblocktime

defines the unit of from and to. block means block number, time means block timestamp, default to block.

frominteger<uint64>

tointeger<uint64>

optionsFilterOptions

pass these parameters if you need filtered results paged. e.g.

Copied!

{
  "options": {
    "offset": 0,
    "limit": 10   
  }
}

the above refers that page offset is 0, and the page size is 10. pass options null if you don't need to demand paging.

Show child attributes

offsetinteger

offset in matched record set

limitinteger

limit of records to output

addressSetsArray<AddressSetLegacy>

Show child attributes

txOriginstring

senderstring

recipientstring

Parameters

orderstringascdescquery

order of filters, defaults to asc

Response

200OK

Filter transfer logs

curl -X POST 'https://meter.nownodes.io/transfers' \
  -H 'Content-Type: application/json' \
  -d '{
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "addressSets": [
      {
        "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
      }
    ]
  }'

const response = await fetch('https://meter.nownodes.io/transfers', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "range": {
        "unit": "block",
        "from": 0,
        "to": 100000
      },
      "options": {
        "offset": 0,
        "limit": 10
      },
      "addressSets": [
        {
          "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
        }
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/transfers')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "addressSets": [
      {
        "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
      }
    ]
  }'

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

import requests

payload = {
  "range": {
    "unit": "block",
    "from": 0,
    "to": 100000
  },
  "options": {
    "offset": 0,
    "limit": 10
  },
  "addressSets": [
    {
      "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
    }
  ]
}

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

const response = await fetch('https://meter.nownodes.io/transfers', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "range": {
        "unit": "block",
        "from": 0,
        "to": 100000
      },
      "options": {
        "offset": 0,
        "limit": 10
      },
      "addressSets": [
        {
          "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
        }
      ]
    }),
});

const data = await response.json();

const endpoint = "https://meter.nownodes.io/transfers";
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({
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "addressSets": [
      {
        "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
      }
    ]
  });
console.log(result);

const response = await fetch('https://meter.nownodes.io/transfers', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "range": {
        "unit": "block",
        "from": 0,
        "to": 100000
      },
      "options": {
        "offset": 0,
        "limit": 10
      },
      "addressSets": [
        {
          "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
          "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "range": {
    "unit": "block",
    "from": 0,
    "to": 100000
  },
  "options": {
    "offset": 0,
    "limit": 10
  },
  "addressSets": [
    {
      "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
    }
  ]
}

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

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/transfers')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "range": {
      "unit": "block",
      "from": 0,
      "to": 100000
    },
    "options": {
      "offset": 0,
      "limit": 10
    },
    "addressSets": [
      {
        "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
        "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
      }
    ]
  }'

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

Request Body

{
  "range": {
    "unit": "block",
    "from": 0,
    "to": 100000
  },
  "options": {
    "offset": 0,
    "limit": 10
  },
  "addressSets": [
    {
      "txOrigin": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "sender": "0xe59d475abe695c7f67a8a2321f33a856b0b4c71d",
      "recipient": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed"
    }
  ]
}

200

[
  {
    "sender": "0xdb4027477b2a8fe4c83c6dafe7f86678bb1b8a8d",
    "recipient": "0x5034aa590125b64023a0262112b98d72e3c8e40e",
    "amount": "0x47fdb3c3f456c0000",
    "meta": {
      "blockID": "0x0004f6cc88bb4626a92907718e82f255b8fa511453a78e8797eb8cea3393b215",
      "blockNumber": 325324,
      "blockTimestamp": 1533267900,
      "txID": "0x284bba50ef777889ff1a367ed0b38d5e5626714477c40de38d71cedd6f9fa477",
      "txOrigin": "0xdb4027477b2a8fe4c83c6dafe7f86678bb1b8a8d"
    }
  }
]

Node

Access to node status info

Retrieve connected peers

GET

https://meter.nownodes.io/node/network/peers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

Retrieve connected peers

curl -X GET 'https://meter.nownodes.io/node/network/peers'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/node/network/peers')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://meter.nownodes.io/node/network/peers')
data = response.json()

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

const data = await response.json();

const endpoint = "https://meter.nownodes.io/node/network/peers";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://meter.nownodes.io/node/network/peers')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/node/network/peers')
request = Net::HTTP::Get.new(uri)

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

Retrieve current committee members

GET

https://meter.nownodes.io/node/consensus/committee

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieve current committee members

curl -X GET 'https://meter.nownodes.io/node/consensus/committee'

const response = await fetch('https://meter.nownodes.io/node/consensus/committee', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/node/consensus/committee')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://meter.nownodes.io/node/consensus/committee')
data = response.json()

const response = await fetch('https://meter.nownodes.io/node/consensus/committee', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://meter.nownodes.io/node/consensus/committee";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://meter.nownodes.io/node/consensus/committee', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://meter.nownodes.io/node/consensus/committee')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/node/consensus/committee')
request = Net::HTTP::Get.new(uri)

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

Subscriptions

Subscribe interested subjects

(Websocket) Subscribe new blocks

GET

https://meter.nownodes.io/subscriptions/block

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

posstringquery

a saved block ID for resuming the subscription. best block ID is assumed if omitted.

Response

200OK

(Websocket) Subscribe new blocks

curl -X GET 'https://meter.nownodes.io/subscriptions/block'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/subscriptions/block')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://meter.nownodes.io/subscriptions/block')
data = response.json()

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

const data = await response.json();

const endpoint = "https://meter.nownodes.io/subscriptions/block";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://meter.nownodes.io/subscriptions/block')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/subscriptions/block')
request = Net::HTTP::Get.new(uri)

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

200

{
  "number": 325324,
  "id": "0x0004f6cc88bb4626a92907718e82f255b8fa511453a78e8797eb8cea3393b215",
  "size": 373,
  "parentID": "0x0004f6cb730dbd90fed09d165bfdf33cc0eed47ec068938f6ee7b7c12a4ea98d",
  "timestamp": 1533267900,
  "gasLimit": 11253579,
  "beneficiary": "0xb4094c25f86d628fdd571afc4077f0d0196afb48",
  "gasUsed": 21000,
  "totalScore": 1029988,
  "txsRoot": "0x89dfd9fcd10c9e53d68592cf8b540b280b72d381b868523223992f3e09a806bb",
  "stateRoot": "0x86bcc6d214bc9d8d0dedba1012a63c8317d19ce97f60c8a2ef5c59bbd40d4261",
  "receiptsRoot": "0x15787e2533c470e8a688e6cd17a1ee12d8457778d5f82d2c109e2d6226d8e54e",
  "signer": "0xab7b27fc9e7d29f9f2e5bd361747a5515d0cc2d1",
  "transactions": [
    "0x284bba50ef777889ff1a367ed0b38d5e5626714477c40de38d71cedd6f9fa477"
  ],
  "obsolete": true
}

(Websocket) Subscribe new events

GET

https://meter.nownodes.io/subscriptions/event

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

which satisfy criteria in query.

Parameters

posstringquery

a saved block ID for resuming the subscription. best block ID is assumed if omitted.

addrstringquery

address of event emitter

t0stringquery

topic0 of event

t1stringquery

topic1 of event

t2stringquery

topic2 of event

t3stringquery

topic3 of event

t4stringquery

topic4 of event

Response

200OK

(Websocket) Subscribe new events

curl -X GET 'https://meter.nownodes.io/subscriptions/event'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/subscriptions/event')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://meter.nownodes.io/subscriptions/event')
data = response.json()

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

const data = await response.json();

const endpoint = "https://meter.nownodes.io/subscriptions/event";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://meter.nownodes.io/subscriptions/event')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/subscriptions/event')
request = Net::HTTP::Get.new(uri)

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

200

{
  "address": "0x7567d83b7b8d80addcb281a71d54fc7b3364ffed",
  "topics": [
    "0x4de71f2d588aa8a1ea00fe8312d92966da424d9939a511fc0be81e65fad52af8"
  ],
  "data": "0x4de71f2d588aa8a1ea00fe8312d92966da424d9939a511fc0be81e65fad52af8",
  "obsolete": true,
  "meta": {
    "blockID": "0x0004f6cc88bb4626a92907718e82f255b8fa511453a78e8797eb8cea3393b215",
    "blockNumber": 325324,
    "blockTimestamp": 1533267900,
    "txID": "0x284bba50ef777889ff1a367ed0b38d5e5626714477c40de38d71cedd6f9fa477",
    "txOrigin": "0xdb4027477b2a8fe4c83c6dafe7f86678bb1b8a8d"
  }
}

(Websocket) Subscribe new transfers

GET

https://meter.nownodes.io/subscriptions/transfer

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

which satisfy criteria in query.

Parameters

posstringquery

a saved block ID for resuming the subscription. best block ID is assumed if omitted.

txOriginstringquery

signer address of tx which contains the transfer

senderstringquery

address of token sender

recipientstringquery

address of token recipient

Response

200OK

(Websocket) Subscribe new transfers

curl -X GET 'https://meter.nownodes.io/subscriptions/transfer'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/subscriptions/transfer')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://meter.nownodes.io/subscriptions/transfer')
data = response.json()

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

const data = await response.json();

const endpoint = "https://meter.nownodes.io/subscriptions/transfer";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://meter.nownodes.io/subscriptions/transfer')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/subscriptions/transfer')
request = Net::HTTP::Get.new(uri)

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

200

{
  "sender": "0xdb4027477b2a8fe4c83c6dafe7f86678bb1b8a8d",
  "recipient": "0x5034aa590125b64023a0262112b98d72e3c8e40e",
  "amount": "0x47fdb3c3f456c0000",
  "obsolete": true,
  "meta": {
    "blockID": "0x0004f6cc88bb4626a92907718e82f255b8fa511453a78e8797eb8cea3393b215",
    "blockNumber": 325324,
    "blockTimestamp": 1533267900,
    "txID": "0x284bba50ef777889ff1a367ed0b38d5e5626714477c40de38d71cedd6f9fa477",
    "txOrigin": "0xdb4027477b2a8fe4c83c6dafe7f86678bb1b8a8d"
  }
}

(Websocket) Subscribe block chain's beats

GET

https://meter.nownodes.io/subscriptions/beat

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

which contain summary of new blocks, and bloom filters that composited with affected addresses.

Parameters

posstringquery

a saved block ID for resuming the subscription. best block ID is assumed if omitted.

Response

200OK

(Websocket) Subscribe block chain's beats

curl -X GET 'https://meter.nownodes.io/subscriptions/beat'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/subscriptions/beat')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://meter.nownodes.io/subscriptions/beat')
data = response.json()

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

const data = await response.json();

const endpoint = "https://meter.nownodes.io/subscriptions/beat";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://meter.nownodes.io/subscriptions/beat')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/subscriptions/beat')
request = Net::HTTP::Get.new(uri)

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

200

{
  "number": 325324,
  "id": "0x0004f6cc88bb4626a92907718e82f255b8fa511453a78e8797eb8cea3393b215",
  "parentID": "0x0004f6cb730dbd90fed09d165bfdf33cc0eed47ec068938f6ee7b7c12a4ea98d",
  "timestamp": 1533267900,
  "bloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
  "k": 3,
  "obsolete": true
}

Debug

Debug utilities

Create a tracer

POST

https://meter.nownodes.io/debug/tracers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

for a clause

Body

application/json

namestring4bytebigramcallevmdisnoopopcountprestatetrigramunigram

name of tracer. Empty name stands for default struct logger tracer.

targetstring

the unified path of target to be traced. Currently, only clause is supported. Format: blockID/(txIndex|txId)/clauseIndex

Response

200OK

Create a tracer

curl -X POST 'https://meter.nownodes.io/debug/tracers' \
  -H 'Content-Type: application/json' \
  -d '{
    "name": "",
    "target": "0x000dabb4d6f0a80ad7ad7cd0e07a1f20b546db0730d869d5ccb0dd2a16e7595b/0/0"
  }'

const response = await fetch('https://meter.nownodes.io/debug/tracers', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "name": "",
      "target": "0x000dabb4d6f0a80ad7ad7cd0e07a1f20b546db0730d869d5ccb0dd2a16e7595b/0/0"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/debug/tracers')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "name": "",
    "target": "0x000dabb4d6f0a80ad7ad7cd0e07a1f20b546db0730d869d5ccb0dd2a16e7595b/0/0"
  }'

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

import requests

payload = {
  "name": "",
  "target": "0x000dabb4d6f0a80ad7ad7cd0e07a1f20b546db0730d869d5ccb0dd2a16e7595b/0/0"
}

response = requests.post('https://meter.nownodes.io/debug/tracers', json=payload)
data = response.json()

const response = await fetch('https://meter.nownodes.io/debug/tracers', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "name": "",
      "target": "0x000dabb4d6f0a80ad7ad7cd0e07a1f20b546db0730d869d5ccb0dd2a16e7595b/0/0"
    }),
});

const data = await response.json();

const endpoint = "https://meter.nownodes.io/debug/tracers";
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({
    "name": "",
    "target": "0x000dabb4d6f0a80ad7ad7cd0e07a1f20b546db0730d869d5ccb0dd2a16e7595b/0/0"
  });
console.log(result);

const response = await fetch('https://meter.nownodes.io/debug/tracers', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "name": "",
      "target": "0x000dabb4d6f0a80ad7ad7cd0e07a1f20b546db0730d869d5ccb0dd2a16e7595b/0/0"
    }),
});

const data = await response.json();

import requests

payload = {
  "name": "",
  "target": "0x000dabb4d6f0a80ad7ad7cd0e07a1f20b546db0730d869d5ccb0dd2a16e7595b/0/0"
}

response = requests.post('https://meter.nownodes.io/debug/tracers', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/debug/tracers')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "name": "",
    "target": "0x000dabb4d6f0a80ad7ad7cd0e07a1f20b546db0730d869d5ccb0dd2a16e7595b/0/0"
  }'

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

Request Body

{
  "name": "",
  "target": "0x000dabb4d6f0a80ad7ad7cd0e07a1f20b546db0730d869d5ccb0dd2a16e7595b/0/0"
}

200

{}

Retrieve storage range

POST

https://meter.nownodes.io/debug/storage-range

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

of the account with given address

Body

application/json

addressstring

address of account

keyStartstring

maxResultnumber

targetstring

Response

200OK

Retrieve storage range

curl -X POST 'https://meter.nownodes.io/debug/storage-range' \
  -H 'Content-Type: application/json' \
  -d '{
    "address": "0xa4627036e2095eb71c2341054daa63577c062498",
    "keyStart": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "maxResult": 10,
    "target": "0x000edefb448685f9c72fc2b946980ef51d8d208bbaa4d3fdcf0c57d4847aca2e/0/0"
  }'

const response = await fetch('https://meter.nownodes.io/debug/storage-range', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "0xa4627036e2095eb71c2341054daa63577c062498",
      "keyStart": "0x0000000000000000000000000000000000000000000000000000000000000000",
      "maxResult": 10,
      "target": "0x000edefb448685f9c72fc2b946980ef51d8d208bbaa4d3fdcf0c57d4847aca2e/0/0"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/debug/storage-range')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "0xa4627036e2095eb71c2341054daa63577c062498",
    "keyStart": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "maxResult": 10,
    "target": "0x000edefb448685f9c72fc2b946980ef51d8d208bbaa4d3fdcf0c57d4847aca2e/0/0"
  }'

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

import requests

payload = {
  "address": "0xa4627036e2095eb71c2341054daa63577c062498",
  "keyStart": "0x0000000000000000000000000000000000000000000000000000000000000000",
  "maxResult": 10,
  "target": "0x000edefb448685f9c72fc2b946980ef51d8d208bbaa4d3fdcf0c57d4847aca2e/0/0"
}

response = requests.post('https://meter.nownodes.io/debug/storage-range', json=payload)
data = response.json()

const response = await fetch('https://meter.nownodes.io/debug/storage-range', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "0xa4627036e2095eb71c2341054daa63577c062498",
      "keyStart": "0x0000000000000000000000000000000000000000000000000000000000000000",
      "maxResult": 10,
      "target": "0x000edefb448685f9c72fc2b946980ef51d8d208bbaa4d3fdcf0c57d4847aca2e/0/0"
    }),
});

const data = await response.json();

const endpoint = "https://meter.nownodes.io/debug/storage-range";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "address": "0xa4627036e2095eb71c2341054daa63577c062498",
    "keyStart": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "maxResult": 10,
    "target": "0x000edefb448685f9c72fc2b946980ef51d8d208bbaa4d3fdcf0c57d4847aca2e/0/0"
  });
console.log(result);

const response = await fetch('https://meter.nownodes.io/debug/storage-range', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "0xa4627036e2095eb71c2341054daa63577c062498",
      "keyStart": "0x0000000000000000000000000000000000000000000000000000000000000000",
      "maxResult": 10,
      "target": "0x000edefb448685f9c72fc2b946980ef51d8d208bbaa4d3fdcf0c57d4847aca2e/0/0"
    }),
});

const data = await response.json();

import requests

payload = {
  "address": "0xa4627036e2095eb71c2341054daa63577c062498",
  "keyStart": "0x0000000000000000000000000000000000000000000000000000000000000000",
  "maxResult": 10,
  "target": "0x000edefb448685f9c72fc2b946980ef51d8d208bbaa4d3fdcf0c57d4847aca2e/0/0"
}

response = requests.post('https://meter.nownodes.io/debug/storage-range', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/debug/storage-range')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "0xa4627036e2095eb71c2341054daa63577c062498",
    "keyStart": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "maxResult": 10,
    "target": "0x000edefb448685f9c72fc2b946980ef51d8d208bbaa4d3fdcf0c57d4847aca2e/0/0"
  }'

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

Request Body

{
  "address": "0xa4627036e2095eb71c2341054daa63577c062498",
  "keyStart": "0x0000000000000000000000000000000000000000000000000000000000000000",
  "maxResult": 10,
  "target": "0x000edefb448685f9c72fc2b946980ef51d8d208bbaa4d3fdcf0c57d4847aca2e/0/0"
}

200

{
  "nextKey": null,
  "storage": {
    "0x33e423980c9b37d048bd5fadbd4a2aeb95146922045405accc2f468d0ef96988": {
      "key": "0x0000000000000000000000000000000000000000000000000000000000000001",
      "value": "0x00000000000000000000000000000000000000000000000000000000000000c8"
    }
  }
}

Staking

Access to staking data

Retrieve staking buckets

GET

https://meter.nownodes.io/staking/buckets

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieve staking buckets

curl -X GET 'https://meter.nownodes.io/staking/buckets'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/staking/buckets')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://meter.nownodes.io/staking/buckets')
data = response.json()

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

const data = await response.json();

const endpoint = "https://meter.nownodes.io/staking/buckets";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://meter.nownodes.io/staking/buckets')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/staking/buckets')
request = Net::HTTP::Get.new(uri)

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

Retrieve staking candidates

GET

https://meter.nownodes.io/staking/candidates

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieve staking candidates

curl -X GET 'https://meter.nownodes.io/staking/candidates'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/staking/candidates')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://meter.nownodes.io/staking/candidates')
data = response.json()

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

const data = await response.json();

const endpoint = "https://meter.nownodes.io/staking/candidates";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://meter.nownodes.io/staking/candidates')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/staking/candidates')
request = Net::HTTP::Get.new(uri)

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

Retrieve staking stakeholder

GET

https://meter.nownodes.io/staking/stakeholders

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieve staking stakeholder

curl -X GET 'https://meter.nownodes.io/staking/stakeholders'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/staking/stakeholders')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://meter.nownodes.io/staking/stakeholders')
data = response.json()

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

const data = await response.json();

const endpoint = "https://meter.nownodes.io/staking/stakeholders";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://meter.nownodes.io/staking/stakeholders')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/staking/stakeholders')
request = Net::HTTP::Get.new(uri)

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

Retrieve staking delegates for consensus

GET

https://meter.nownodes.io/staking/delegates

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieve staking delegates for consensus

curl -X GET 'https://meter.nownodes.io/staking/delegates'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/staking/delegates')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://meter.nownodes.io/staking/delegates')
data = response.json()

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

const data = await response.json();

const endpoint = "https://meter.nownodes.io/staking/delegates";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://meter.nownodes.io/staking/delegates')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://meter.nownodes.io/staking/delegates')
request = Net::HTTP::Get.new(uri)

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

Documentation

How to migrate to NOWNodes

Authentication

API Reference

Accounts

Authorizations

Parameters

Response

Authorizations

Body

Parameters

Response

Authorizations

Body

Parameters

Response

Authorizations

TIPS:

Body

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Transactions

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Body

Response

Blocks

Authorizations

Parameters

Response

Logs

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Parameters

Response

Authorizations

Body

Parameters

Response

Authorizations

Body

Parameters

Response

Authorizations

Body

Parameters

Response

Node

Authorizations

Response

Authorizations

Subscriptions

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters